utils.c@ 58106

Last change on this file since 58106 was 54391, checked in by vboxsync, 10 years ago
Additions/linux/vboxsf: fix for Linux 4.0
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.3 KB

Line
1	/** @file
2	*
3	* vboxsf -- VirtualBox Guest Additions for Linux:
4	* Utility functions.
5	* Mainly conversion from/to VirtualBox/Linux data structures
6	*/
7
8	/*
9	* Copyright (C) 2006-2012 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19
20	#include "vfsmod.h"
21	#include <iprt/asm.h>
22	#include <linux/nfs_fs.h>
23	#include <linux/vfs.h>
24
25	/* #define USE_VMALLOC */
26
27	/*
28	* sf_reg_aops and sf_backing_dev_info are just quick implementations to make
29	* sendfile work. For more information have a look at
30	*
31	* http://us1.samba.org/samba/ftp/cifs-cvs/ols2006-fs-tutorial-smf.odp
32	*
33	* and the sample implementation
34	*
35	* http://pserver.samba.org/samba/ftp/cifs-cvs/samplefs.tar.gz
36	*/
37
38	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
39	static void sf_ftime_from_timespec(time_t time, RTTIMESPEC ts)
40	{
41	int64_t t = RTTimeSpecGetNano(ts);
42
43	do_div(t, 1000000000);
44	*time = t;
45	}
46
47	static void sf_timespec_from_ftime(RTTIMESPEC ts, time_t time)
48	{
49	int64_t t = 1000000000 * *time;
50	RTTimeSpecSetNano(ts, t);
51	}
52	#else /* >= 2.6.0 */
53	static void sf_ftime_from_timespec(struct timespec tv, RTTIMESPEC ts)
54	{
55	int64_t t = RTTimeSpecGetNano(ts);
56	int64_t nsec;
57
58	nsec = do_div(t, 1000000000);
59	tv->tv_sec = t;
60	tv->tv_nsec = nsec;
61	}
62
63	static void sf_timespec_from_ftime(RTTIMESPEC ts, struct timespec tv)
64	{
65	int64_t t = (int64_t)tv->tv_nsec + (int64_t)tv->tv_sec * 1000000000;
66	RTTimeSpecSetNano(ts, t);
67	}
68	#endif /* >= 2.6.0 */
69
70	/* set [inode] attributes based on [info], uid/gid based on [sf_g] */
71	void sf_init_inode(struct sf_glob_info sf_g, struct inode inode,
72	PSHFLFSOBJINFO info)
73	{
74	PSHFLFSOBJATTR attr;
75	int mode;
76
77	TRACE();
78
79	attr = &info->Attr;
80
81	#define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0;
82	mode = mode_set(ISUID);
83	mode \|= mode_set(ISGID);
84
85	mode \|= mode_set(IRUSR);
86	mode \|= mode_set(IWUSR);
87	mode \|= mode_set(IXUSR);
88
89	mode \|= mode_set(IRGRP);
90	mode \|= mode_set(IWGRP);
91	mode \|= mode_set(IXGRP);
92
93	mode \|= mode_set(IROTH);
94	mode \|= mode_set(IWOTH);
95	mode \|= mode_set(IXOTH);
96
97	#undef mode_set
98
99	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
100	inode->i_mapping->a_ops = &sf_reg_aops;
101	# if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
102	/* XXX Was this ever necessary? */
103	inode->i_mapping->backing_dev_info = &sf_g->bdi;
104	# endif
105	#endif
106
107	if (RTFS_IS_DIRECTORY(attr->fMode))
108	{
109	inode->i_mode = sf_g->dmode != ~0 ? (sf_g->dmode & 0777) : mode;
110	inode->i_mode &= ~sf_g->dmask;
111	inode->i_mode \|= S_IFDIR;
112	inode->i_op = &sf_dir_iops;
113	inode->i_fop = &sf_dir_fops;
114	/* XXX: this probably should be set to the number of entries
115	in the directory plus two (. ..) */
116	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
117	set_nlink(inode, 1);
118	#else
119	inode->i_nlink = 1;
120	#endif
121	}
122	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
123	else if (RTFS_IS_SYMLINK(attr->fMode))
124	{
125	inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
126	inode->i_mode &= ~sf_g->fmask;
127	inode->i_mode \|= S_IFLNK;
128	inode->i_op = &sf_lnk_iops;
129	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
130	set_nlink(inode, 1);
131	# else
132	inode->i_nlink = 1;
133	# endif
134	}
135	#endif
136	else
137	{
138	inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
139	inode->i_mode &= ~sf_g->fmask;
140	inode->i_mode \|= S_IFREG;
141	inode->i_op = &sf_reg_iops;
142	inode->i_fop = &sf_reg_fops;
143	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
144	set_nlink(inode, 1);
145	#else
146	inode->i_nlink = 1;
147	#endif
148	}
149
150	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
151	inode->i_uid = make_kuid(current_user_ns(), sf_g->uid);
152	inode->i_gid = make_kgid(current_user_ns(), sf_g->gid);
153	#else
154	inode->i_uid = sf_g->uid;
155	inode->i_gid = sf_g->gid;
156	#endif
157
158	inode->i_size = info->cbObject;
159	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6)
160	inode->i_blksize = 4096;
161	#endif
162	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11)
163	inode->i_blkbits = 12;
164	#endif
165	/* i_blocks always in units of 512 bytes! */
166	inode->i_blocks = (info->cbAllocated + 511) / 512;
167
168	sf_ftime_from_timespec(&inode->i_atime, &info->AccessTime);
169	sf_ftime_from_timespec(&inode->i_ctime, &info->ChangeTime);
170	sf_ftime_from_timespec(&inode->i_mtime, &info->ModificationTime);
171	}
172
173	int sf_stat(const char caller, struct sf_glob_info sf_g,
174	SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
175	{
176	int rc;
177	SHFLCREATEPARMS params;
178	NOREF(caller);
179
180	TRACE();
181
182	RT_ZERO(params);
183	params.Handle = SHFL_HANDLE_NIL;
184	params.CreateFlags = SHFL_CF_LOOKUP \| SHFL_CF_ACT_FAIL_IF_NEW;
185	LogFunc(("sf_stat: calling vboxCallCreate, file %s, flags %#x\n",
186	path->String.utf8, params.CreateFlags));
187	rc = vboxCallCreate(&client_handle, &sf_g->map, path, &params);
188	if (rc == VERR_INVALID_NAME)
189	{
190	/* this can happen for names like 'foo' on a Windows host /
191	return -ENOENT;
192	}
193	if (RT_FAILURE(rc))
194	{
195	LogFunc(("vboxCallCreate(%s) failed. caller=%s, rc=%Rrc\n",
196	path->String.utf8, rc, caller));
197	return -EPROTO;
198	}
199	if (params.Result != SHFL_FILE_EXISTS)
200	{
201	if (!ok_to_fail)
202	LogFunc(("vboxCallCreate(%s) file does not exist. caller=%s, result=%d\n",
203	path->String.utf8, params.Result, caller));
204	return -ENOENT;
205	}
206
207	*result = params.Info;
208	return 0;
209	}
210
211	/* this is called directly as iop on 2.4, indirectly as dop
212	[sf_dentry_revalidate] on 2.4/2.6, indirectly as iop through
213	[sf_getattr] on 2.6. the job is to find out whether dentry/inode is
214	still valid. the test is failed if [dentry] does not have an inode
215	or [sf_stat] is unsuccessful, otherwise we return success and
216	update inode attributes */
217	int sf_inode_revalidate(struct dentry *dentry)
218	{
219	int err;
220	struct sf_glob_info *sf_g;
221	struct sf_inode_info *sf_i;
222	SHFLFSOBJINFO info;
223
224	TRACE();
225	if (!dentry \|\| !dentry->d_inode)
226	{
227	LogFunc(("no dentry(%p) or inode(%p)\n", dentry, dentry->d_inode));
228	return -EINVAL;
229	}
230
231	sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
232	sf_i = GET_INODE_INFO(dentry->d_inode);
233
234	#if 0
235	printk("%s called by %p:%p\n",
236	sf_i->path->String.utf8,
237	__builtin_return_address (0),
238	__builtin_return_address (1));
239	#endif
240
241	BUG_ON(!sf_g);
242	BUG_ON(!sf_i);
243
244	if (!sf_i->force_restat)
245	{
246	if (jiffies - dentry->d_time < sf_g->ttl)
247	return 0;
248	}
249
250	err = sf_stat(__func__, sf_g, sf_i->path, &info, 1);
251	if (err)
252	return err;
253
254	dentry->d_time = jiffies;
255	sf_init_inode(sf_g, dentry->d_inode, &info);
256	return 0;
257	}
258
259	/* this is called during name resolution/lookup to check if the
260	[dentry] in the cache is still valid. the job is handled by
261	[sf_inode_revalidate] */
262	static int
263	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
264	sf_dentry_revalidate(struct dentry *dentry, unsigned flags)
265	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
266	sf_dentry_revalidate(struct dentry dentry, struct nameidata nd)
267	#else
268	sf_dentry_revalidate(struct dentry *dentry, int flags)
269	#endif
270	{
271	TRACE();
272
273	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
274	if (flags & LOOKUP_RCU)
275	return -ECHILD;
276	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
277	/* see Documentation/filesystems/vfs.txt */
278	if (nd && nd->flags & LOOKUP_RCU)
279	return -ECHILD;
280	#endif
281
282	if (sf_inode_revalidate(dentry))
283	return 0;
284
285	return 1;
286	}
287
288	/* on 2.6 this is a proxy for [sf_inode_revalidate] which (as a side
289	effect) updates inode attributes for [dentry] (given that [dentry]
290	has inode at all) from these new attributes we derive [kstat] via
291	[generic_fillattr] */
292	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
293	int sf_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat *kstat)
294	{
295	int err;
296
297	TRACE();
298	err = sf_inode_revalidate(dentry);
299	if (err)
300	return err;
301
302	generic_fillattr(dentry->d_inode, kstat);
303	return 0;
304	}
305
306	int sf_setattr(struct dentry dentry, struct iattr iattr)
307	{
308	struct sf_glob_info *sf_g;
309	struct sf_inode_info *sf_i;
310	SHFLCREATEPARMS params;
311	SHFLFSOBJINFO info;
312	uint32_t cbBuffer;
313	int rc, err;
314
315	TRACE();
316
317	sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
318	sf_i = GET_INODE_INFO(dentry->d_inode);
319	err = 0;
320
321	RT_ZERO(params);
322	params.Handle = SHFL_HANDLE_NIL;
323	params.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
324	\| SHFL_CF_ACT_FAIL_IF_NEW
325	\| SHFL_CF_ACCESS_ATTR_WRITE;
326
327	/* this is at least required for Posix hosts */
328	if (iattr->ia_valid & ATTR_SIZE)
329	params.CreateFlags \|= SHFL_CF_ACCESS_WRITE;
330
331	rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
332	if (RT_FAILURE(rc))
333	{
334	LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n",
335	sf_i->path->String.utf8, rc));
336	err = -RTErrConvertToErrno(rc);
337	goto fail2;
338	}
339	if (params.Result != SHFL_FILE_EXISTS)
340	{
341	LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
342	err = -ENOENT;
343	goto fail1;
344	}
345
346	/* Setting the file size and setting the other attributes has to be
347	* handled separately, see implementation of vbsfSetFSInfo() in
348	* vbsf.cpp */
349	if (iattr->ia_valid & (ATTR_MODE \| ATTR_ATIME \| ATTR_MTIME))
350	{
351	#define mode_set(r) ((iattr->ia_mode & (S_##r)) ? RTFS_UNIX_##r : 0)
352
353	RT_ZERO(info);
354	if (iattr->ia_valid & ATTR_MODE)
355	{
356	info.Attr.fMode = mode_set(ISUID);
357	info.Attr.fMode \|= mode_set(ISGID);
358	info.Attr.fMode \|= mode_set(IRUSR);
359	info.Attr.fMode \|= mode_set(IWUSR);
360	info.Attr.fMode \|= mode_set(IXUSR);
361	info.Attr.fMode \|= mode_set(IRGRP);
362	info.Attr.fMode \|= mode_set(IWGRP);
363	info.Attr.fMode \|= mode_set(IXGRP);
364	info.Attr.fMode \|= mode_set(IROTH);
365	info.Attr.fMode \|= mode_set(IWOTH);
366	info.Attr.fMode \|= mode_set(IXOTH);
367
368	if (iattr->ia_mode & S_IFDIR)
369	info.Attr.fMode \|= RTFS_TYPE_DIRECTORY;
370	else
371	info.Attr.fMode \|= RTFS_TYPE_FILE;
372	}
373
374	if (iattr->ia_valid & ATTR_ATIME)
375	sf_timespec_from_ftime(&info.AccessTime, &iattr->ia_atime);
376	if (iattr->ia_valid & ATTR_MTIME)
377	sf_timespec_from_ftime(&info.ModificationTime, &iattr->ia_mtime);
378	/* ignore ctime (inode change time) as it can't be set from userland anyway */
379
380	cbBuffer = sizeof(info);
381	rc = vboxCallFSInfo(&client_handle, &sf_g->map, params.Handle,
382	SHFL_INFO_SET \| SHFL_INFO_FILE, &cbBuffer,
383	(PSHFLDIRINFO)&info);
384	if (RT_FAILURE(rc))
385	{
386	LogFunc(("vboxCallFSInfo(%s, FILE) failed rc=%Rrc\n",
387	sf_i->path->String.utf8, rc));
388	err = -RTErrConvertToErrno(rc);
389	goto fail1;
390	}
391	}
392
393	if (iattr->ia_valid & ATTR_SIZE)
394	{
395	RT_ZERO(info);
396	info.cbObject = iattr->ia_size;
397	cbBuffer = sizeof(info);
398	rc = vboxCallFSInfo(&client_handle, &sf_g->map, params.Handle,
399	SHFL_INFO_SET \| SHFL_INFO_SIZE, &cbBuffer,
400	(PSHFLDIRINFO)&info);
401	if (RT_FAILURE(rc))
402	{
403	LogFunc(("vboxCallFSInfo(%s, SIZE) failed rc=%Rrc\n",
404	sf_i->path->String.utf8, rc));
405	err = -RTErrConvertToErrno(rc);
406	goto fail1;
407	}
408	}
409
410	rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
411	if (RT_FAILURE(rc))
412	LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
413
414	return sf_inode_revalidate(dentry);
415
416	fail1:
417	rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
418	if (RT_FAILURE(rc))
419	LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
420
421	fail2:
422	return err;
423	}
424	#endif /* >= 2.6.0 */
425
426	static int sf_make_path(const char caller, struct sf_inode_info sf_i,
427	const char d_name, size_t d_len, SHFLSTRING *result)
428	{
429	size_t path_len, shflstring_len;
430	SHFLSTRING *tmp;
431	uint16_t p_len;
432	uint8_t *p_name;
433	int fRoot = 0;
434
435	TRACE();
436	p_len = sf_i->path->u16Length;
437	p_name = sf_i->path->String.utf8;
438
439	if (p_len == 1 && *p_name == '/')
440	{
441	path_len = d_len + 1;
442	fRoot = 1;
443	}
444	else
445	{
446	/* lengths of constituents plus terminating zero plus slash */
447	path_len = p_len + d_len + 2;
448	if (path_len > 0xffff)
449	{
450	LogFunc(("path too long. caller=%s, path_len=%zu\n", caller, path_len));
451	return -ENAMETOOLONG;
452	}
453	}
454
455	shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len;
456	tmp = kmalloc(shflstring_len, GFP_KERNEL);
457	if (!tmp)
458	{
459	LogRelFunc(("kmalloc failed, caller=%s\n", caller));
460	return -ENOMEM;
461	}
462	tmp->u16Length = path_len - 1;
463	tmp->u16Size = path_len;
464
465	if (fRoot)
466	memcpy(&tmp->String.utf8[0], d_name, d_len + 1);
467	else
468	{
469	memcpy(&tmp->String.utf8[0], p_name, p_len);
470	tmp->String.utf8[p_len] = '/';
471	memcpy(&tmp->String.utf8[p_len + 1], d_name, d_len);
472	tmp->String.utf8[p_len + 1 + d_len] = '\0';
473	}
474
475	*result = tmp;
476	return 0;
477	}
478
479	/**
480	* [dentry] contains string encoded in coding system that corresponds
481	* to [sf_g]->nls, we must convert it to UTF8 here and pass down to
482	* [sf_make_path] which will allocate SHFLSTRING and fill it in
483	*/
484	int sf_path_from_dentry(const char caller, struct sf_glob_info sf_g,
485	struct sf_inode_info sf_i, struct dentry dentry,
486	SHFLSTRING **result)
487	{
488	int err;
489	const char *d_name;
490	size_t d_len;
491	const char *name;
492	size_t len = 0;
493
494	TRACE();
495	d_name = dentry->d_name.name;
496	d_len = dentry->d_name.len;
497
498	if (sf_g->nls)
499	{
500	size_t in_len, i, out_bound_len;
501	const char *in;
502	char *out;
503
504	in = d_name;
505	in_len = d_len;
506
507	out_bound_len = PATH_MAX;
508	out = kmalloc(out_bound_len, GFP_KERNEL);
509	name = out;
510
511	for (i = 0; i < d_len; ++i)
512	{
513	/* We renamed the linux kernel wchar_t type to linux_wchar_t in
514	the-linux-kernel.h, as it conflicts with the C++ type of that name. */
515	linux_wchar_t uni;
516	int nb;
517
518	nb = sf_g->nls->char2uni(in, in_len, &uni);
519	if (nb < 0)
520	{
521	LogFunc(("nls->char2uni failed %x %d\n",
522	*in, in_len));
523	err = -EINVAL;
524	goto fail1;
525	}
526	in_len -= nb;
527	in += nb;
528
529	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
530	nb = utf32_to_utf8(uni, out, out_bound_len);
531	#else
532	nb = utf8_wctomb(out, uni, out_bound_len);
533	#endif
534	if (nb < 0)
535	{
536	LogFunc(("nls->uni2char failed %x %d\n",
537	uni, out_bound_len));
538	err = -EINVAL;
539	goto fail1;
540	}
541	out_bound_len -= nb;
542	out += nb;
543	len += nb;
544	}
545	if (len >= PATH_MAX - 1)
546	{
547	err = -ENAMETOOLONG;
548	goto fail1;
549	}
550
551	LogFunc(("result(%d) = %.*s\n", len, len, name));
552	*out = 0;
553	}
554	else
555	{
556	name = d_name;
557	len = d_len;
558	}
559
560	err = sf_make_path(caller, sf_i, name, len, result);
561	if (name != d_name)
562	kfree(name);
563
564	return err;
565
566	fail1:
567	kfree(name);
568	return err;
569	}
570
571	int sf_nlscpy(struct sf_glob_info *sf_g,
572	char *name, size_t name_bound_len,
573	const unsigned char *utf8_name, size_t utf8_len)
574	{
575	if (sf_g->nls)
576	{
577	const char *in;
578	char *out;
579	size_t out_len;
580	size_t out_bound_len;
581	size_t in_bound_len;
582
583	in = utf8_name;
584	in_bound_len = utf8_len;
585
586	out = name;
587	out_len = 0;
588	out_bound_len = name_bound_len;
589
590	while (in_bound_len)
591	{
592	int nb;
593	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
594	unicode_t uni;
595
596	nb = utf8_to_utf32(in, in_bound_len, &uni);
597	#else
598	linux_wchar_t uni;
599
600	nb = utf8_mbtowc(&uni, in, in_bound_len);
601	#endif
602	if (nb < 0)
603	{
604	LogFunc(("utf8_mbtowc failed(%s) %x:%d\n",
605	(const char ) utf8_name, in, in_bound_len));
606	return -EINVAL;
607	}
608	in += nb;
609	in_bound_len -= nb;
610
611	nb = sf_g->nls->uni2char(uni, out, out_bound_len);
612	if (nb < 0)
613	{
614	LogFunc(("nls->uni2char failed(%s) %x:%d\n",
615	utf8_name, uni, out_bound_len));
616	return nb;
617	}
618	out += nb;
619	out_bound_len -= nb;
620	out_len += nb;
621	}
622
623	*out = 0;
624	}
625	else
626	{
627	if (utf8_len + 1 > name_bound_len)
628	return -ENAMETOOLONG;
629
630	memcpy(name, utf8_name, utf8_len + 1);
631	}
632	return 0;
633	}
634
635	static struct sf_dir_buf *sf_dir_buf_alloc(void)
636	{
637	struct sf_dir_buf *b;
638
639	TRACE();
640	b = kmalloc(sizeof(*b), GFP_KERNEL);
641	if (!b)
642	{
643	LogRelFunc(("could not alloc directory buffer\n"));
644	return NULL;
645	}
646
647	#ifdef USE_VMALLOC
648	b->buf = vmalloc(DIR_BUFFER_SIZE);
649	#else
650	b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
651	#endif
652	if (!b->buf)
653	{
654	kfree(b);
655	LogRelFunc(("could not alloc directory buffer storage\n"));
656	return NULL;
657	}
658
659	INIT_LIST_HEAD(&b->head);
660	b->cEntries = 0;
661	b->cbUsed = 0;
662	b->cbFree = DIR_BUFFER_SIZE;
663	return b;
664	}
665
666	static void sf_dir_buf_free(struct sf_dir_buf *b)
667	{
668	BUG_ON(!b \|\| !b->buf);
669
670	TRACE();
671	list_del(&b->head);
672	#ifdef USE_VMALLOC
673	vfree(b->buf);
674	#else
675	kfree(b->buf);
676	#endif
677	kfree(b);
678	}
679
680	/**
681	* Free the directory buffer.
682	*/
683	void sf_dir_info_free(struct sf_dir_info *p)
684	{
685	struct list_head list, pos, *tmp;
686
687	TRACE();
688	list = &p->info_list;
689	list_for_each_safe(pos, tmp, list)
690	{
691	struct sf_dir_buf *b;
692
693	b = list_entry(pos, struct sf_dir_buf, head);
694	sf_dir_buf_free(b);
695	}
696	kfree(p);
697	}
698
699	/**
700	* Empty (but not free) the directory buffer.
701	*/
702	void sf_dir_info_empty(struct sf_dir_info *p)
703	{
704	struct list_head list, pos, *tmp;
705	TRACE();
706	list = &p->info_list;
707	list_for_each_safe(pos, tmp, list)
708	{
709	struct sf_dir_buf *b;
710	b = list_entry(pos, struct sf_dir_buf, head);
711	b->cEntries = 0;
712	b->cbUsed = 0;
713	b->cbFree = DIR_BUFFER_SIZE;
714	}
715	}
716
717	/**
718	* Create a new directory buffer descriptor.
719	*/
720	struct sf_dir_info *sf_dir_info_alloc(void)
721	{
722	struct sf_dir_info *p;
723
724	TRACE();
725	p = kmalloc(sizeof(*p), GFP_KERNEL);
726	if (!p)
727	{
728	LogRelFunc(("could not alloc directory info\n"));
729	return NULL;
730	}
731
732	INIT_LIST_HEAD(&p->info_list);
733	return p;
734	}
735
736	/**
737	* Search for an empty directory content buffer.
738	*/
739	static struct sf_dir_buf sf_get_empty_dir_buf(struct sf_dir_info sf_d)
740	{
741	struct list_head list, pos;
742
743	list = &sf_d->info_list;
744	list_for_each(pos, list)
745	{
746	struct sf_dir_buf *b;
747
748	b = list_entry(pos, struct sf_dir_buf, head);
749	if (!b)
750	return NULL;
751	else
752	{
753	if (b->cbUsed == 0)
754	return b;
755	}
756	}
757
758	return NULL;
759	}
760
761	int sf_dir_read_all(struct sf_glob_info sf_g, struct sf_inode_info sf_i,
762	struct sf_dir_info *sf_d, SHFLHANDLE handle)
763	{
764	int err;
765	SHFLSTRING *mask;
766	struct sf_dir_buf *b;
767
768	TRACE();
769	err = sf_make_path(__func__, sf_i, "*", 1, &mask);
770	if (err)
771	goto fail0;
772
773	for (;;)
774	{
775	int rc;
776	void *buf;
777	uint32_t cbSize;
778	uint32_t cEntries;
779
780	b = sf_get_empty_dir_buf(sf_d);
781	if (!b)
782	{
783	b = sf_dir_buf_alloc();
784	if (!b)
785	{
786	err = -ENOMEM;
787	LogRelFunc(("could not alloc directory buffer\n"));
788	goto fail1;
789	}
790	list_add(&b->head, &sf_d->info_list);
791	}
792
793	buf = b->buf;
794	cbSize = b->cbFree;
795
796	rc = vboxCallDirInfo(&client_handle, &sf_g->map, handle, mask,
797	0, 0, &cbSize, buf, &cEntries);
798	switch (rc)
799	{
800	case VINF_SUCCESS:
801	/* fallthrough */
802	case VERR_NO_MORE_FILES:
803	break;
804	case VERR_NO_TRANSLATION:
805	LogFunc(("host could not translate entry\n"));
806	/* XXX */
807	break;
808	default:
809	err = -RTErrConvertToErrno(rc);
810	LogFunc(("vboxCallDirInfo failed rc=%Rrc\n", rc));
811	goto fail1;
812	}
813
814	b->cEntries += cEntries;
815	b->cbFree -= cbSize;
816	b->cbUsed += cbSize;
817
818	if (RT_FAILURE(rc))
819	break;
820	}
821	err = 0;
822
823	fail1:
824	kfree(mask);
825
826	fail0:
827	return err;
828	}
829
830	int sf_get_volume_info(struct super_block sb, STRUCT_STATFS stat)
831	{
832	struct sf_glob_info *sf_g;
833	SHFLVOLINFO SHFLVolumeInfo;
834	uint32_t cbBuffer;
835	int rc;
836
837	sf_g = GET_GLOB_INFO(sb);
838	cbBuffer = sizeof(SHFLVolumeInfo);
839	rc = vboxCallFSInfo(&client_handle, &sf_g->map, 0, SHFL_INFO_GET \| SHFL_INFO_VOLUME,
840	&cbBuffer, (PSHFLDIRINFO)&SHFLVolumeInfo);
841	if (RT_FAILURE(rc))
842	return -RTErrConvertToErrno(rc);
843
844	stat->f_type = NFS_SUPER_MAGIC; /* XXX vboxsf type? */
845	stat->f_bsize = SHFLVolumeInfo.ulBytesPerAllocationUnit;
846	stat->f_blocks = SHFLVolumeInfo.ullTotalAllocationBytes
847	/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
848	stat->f_bfree = SHFLVolumeInfo.ullAvailableAllocationBytes
849	/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
850	stat->f_bavail = SHFLVolumeInfo.ullAvailableAllocationBytes
851	/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
852	stat->f_files = 1000;
853	stat->f_ffree = 1000; /* don't return 0 here since the guest may think
854	* that it is not possible to create any more files */
855	stat->f_fsid.val[0] = 0;
856	stat->f_fsid.val[1] = 0;
857	stat->f_namelen = 255;
858	return 0;
859	}
860
861	struct dentry_operations sf_dentry_ops =
862	{
863	.d_revalidate = sf_dentry_revalidate
864	};
865
866	int sf_init_backing_dev(struct sf_glob_info *sf_g)
867	{
868	int rc = 0;
869	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
870	/* Each new shared folder map gets a new uint64_t identifier,
871	* allocated in sequence. We ASSUME the sequence will not wrap. */
872	static uint64_t s_u64Sequence = 0;
873	uint64_t u64CurrentSequence = ASMAtomicIncU64(&s_u64Sequence);
874
875	sf_g->bdi.ra_pages = 0; /* No readahead */
876	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
877	sf_g->bdi.capabilities = BDI_CAP_MAP_DIRECT /* MAP_SHARED */
878	\| BDI_CAP_MAP_COPY /* MAP_PRIVATE */
879	\| BDI_CAP_READ_MAP /* can be mapped for reading */
880	\| BDI_CAP_WRITE_MAP /* can be mapped for writing */
881	\| BDI_CAP_EXEC_MAP; /* can be mapped for execution */
882	# endif /* >= 2.6.12 */
883	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
884	rc = bdi_init(&sf_g->bdi);
885	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
886	if (!rc)
887	rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%llu",
888	(unsigned long long)u64CurrentSequence);
889	# endif /* >= 2.6.26 */
890	# endif /* >= 2.6.24 */
891	#endif /* >= 2.6.0 && <= 3.19.0 */
892	return rc;
893	}
894
895	void sf_done_backing_dev(struct sf_glob_info *sf_g)
896	{
897	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
898	bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */
899	#endif
900	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/linux/sharedfolders/utils.c@ 58106

Download in other formats: