utils.c@ 47588

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

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

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

Download in other formats: