utils.c@ 20348

Last change on this file since 20348 was 20348, checked in by vboxsync, 16 years ago
Linux shared folders: file mode setting function must request write access to attributes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.7 KB

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

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

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

Download in other formats: