vfsmod.c@ 77944

Last change on this file since 77944 was 77863, checked in by vboxsync, 6 years ago
linux/vboxsf: Added support for the RENAME_NOREPLACE flags (since 3.15) and cleaned up the code a little bit. bugref:9172
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.5 KB

Line
1	/* $Id: vfsmod.c 77863 2019-03-24 14:42:15Z vboxsync $ */
2	/** @file
3	* vboxsf - VBox Linux Shared Folders VFS, module init/term, super block management.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* Permission is hereby granted, free of charge, to any person
10	* obtaining a copy of this software and associated documentation
11	* files (the "Software"), to deal in the Software without
12	* restriction, including without limitation the rights to use,
13	* copy, modify, merge, publish, distribute, sublicense, and/or sell
14	* copies of the Software, and to permit persons to whom the
15	* Software is furnished to do so, subject to the following
16	* conditions:
17	*
18	* The above copyright notice and this permission notice shall be
19	* included in all copies or substantial portions of the Software.
20	*
21	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
23	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28	* OTHER DEALINGS IN THE SOFTWARE.
29	*/
30
31	/**
32	* @note Anyone wishing to make changes here might wish to take a look at
33	* https://github.com/torvalds/linux/blob/master/Documentation/filesystems/vfs.txt
34	* which seems to be the closest there is to official documentation on
35	* writing filesystem drivers for Linux.
36	*
37	* See also: http://us1.samba.org/samba/ftp/cifs-cvs/ols2006-fs-tutorial-smf.odp
38	*/
39
40
41	/*********************************************************************************************************************************
42	* Header Files *
43	*********************************************************************************************************************************/
44	#include "vfsmod.h"
45	#include "version-generated.h"
46	#include "revision-generated.h"
47	#include "product-generated.h"
48	#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
49	# include <uapi/linux/mount.h> /* for MS_REMOUNT */
50	#elif LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
51	# include <linux/mount.h>
52	#endif
53	#include <linux/seq_file.h>
54	#include <linux/vfs.h>
55	#include <VBox/err.h>
56	#include <iprt/path.h>
57
58
59	/*********************************************************************************************************************************
60	* Global Variables *
61	*********************************************************************************************************************************/
62	VBGLSFCLIENT g_SfClient;
63	uint32_t g_fHostFeatures = 0;
64	/** Last valid shared folders function number. */
65	uint32_t g_uSfLastFunction = SHFL_FN_SET_FILE_SIZE;
66	/** Shared folders features. */
67	uint64_t g_fSfFeatures = 0;
68
69	/** Protects all the vbsf_inode_info::HandleList lists. */
70	spinlock_t g_SfHandleLock;
71
72	/** The 'follow_symlinks' module parameter.
73	* @todo Figure out how do this for 2.4.x! */
74	static int g_fFollowSymlinks = 0;
75
76	/* forward declaration */
77	static struct super_operations g_vbsf_super_ops;
78
79
80
81	/**
82	* Copies options from the mount info structure into @a sf_g.
83	*
84	* This is used both by vbsf_super_info_alloc_and_map_it() and
85	* vbsf_remount_fs().
86	*/
87	static void vbsf_super_info_copy_remount_options(struct vbsf_super_info sf_g, struct vbsf_mount_info_new info)
88	{
89	sf_g->ttl_msec = info->ttl;
90	if (info->ttl > 0)
91	sf_g->ttl = msecs_to_jiffies(info->ttl);
92	else if (info->ttl == 0 \|\| info->ttl != -1)
93	sf_g->ttl = sf_g->ttl_msec = 0;
94	else
95	sf_g->ttl = msecs_to_jiffies(VBSF_DEFAULT_TTL_MS);
96
97	sf_g->uid = info->uid;
98	sf_g->gid = info->gid;
99
100	if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, tag)) {
101	/* new fields */
102	sf_g->dmode = info->dmode;
103	sf_g->fmode = info->fmode;
104	sf_g->dmask = info->dmask;
105	sf_g->fmask = info->fmask;
106	} else {
107	sf_g->dmode = ~0;
108	sf_g->fmode = ~0;
109	}
110
111	if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, cMaxIoPages)) {
112	AssertCompile(sizeof(sf_g->tag) >= sizeof(info->tag));
113	memcpy(sf_g->tag, info->tag, sizeof(info->tag));
114	sf_g->tag[sizeof(sf_g->tag) - 1] = '\0';
115	} else {
116	sf_g->tag[0] = '\0';
117	}
118
119	/* The max number of pages in an I/O request. This must take into
120	account that the physical heap generally grows in 64 KB chunks,
121	so we should not try push that limit. It also needs to take
122	into account that the host will allocate temporary heap buffers
123	for the I/O bytes we send/receive, so don't push the host heap
124	too hard as we'd have to retry with smaller requests when this
125	happens, which isn't too efficient. */
126	sf_g->cMaxIoPages = RT_MIN(_16K / sizeof(RTGCPHYS64) /* => 8MB buffer */,
127	VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT);
128	if ( (unsigned)info->length >= sizeof(struct vbsf_mount_info_new)
129	&& info->cMaxIoPages > 0) {
130	if (info->cMaxIoPages <= VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT)
131	sf_g->cMaxIoPages = RT_MAX(info->cMaxIoPages, 2); /* read_iter/write_iter requires a minimum of 2. */
132	else
133	printk(KERN_WARNING "vboxsf: max I/O page count (%#x) is out of range, using default (%#x) instead.\n",
134	info->cMaxIoPages, sf_g->cMaxIoPages);
135	}
136
137	sf_g->cbDirBuf = _64K; /** @todo make configurable. */
138	}
139
140	/**
141	* Allocate the super info structure and try map the host share.
142	*/
143	static int vbsf_super_info_alloc_and_map_it(struct vbsf_mount_info_new info, struct vbsf_super_info *sf_gp)
144	{
145	int rc;
146	SHFLSTRING *str_name;
147	size_t name_len, str_len;
148	struct vbsf_super_info *sf_g;
149
150	TRACE();
151
152	/*
153	* Validate info.
154	*/
155	if ( info->nullchar != '\0'
156	\|\| info->signature[0] != VBSF_MOUNT_SIGNATURE_BYTE_0
157	\|\| info->signature[1] != VBSF_MOUNT_SIGNATURE_BYTE_1
158	\|\| info->signature[2] != VBSF_MOUNT_SIGNATURE_BYTE_2) {
159	SFLOGRELBOTH(("vboxsf: Invalid info signature: %#x %#x %#x %#x!\n",
160	info->nullchar, info->signature[0], info->signature[1], info->signature[2]));
161	return -EINVAL;
162	}
163	name_len = RTStrNLen(info->name, sizeof(info->name));
164	if (name_len >= sizeof(info->name)) {
165	SFLOGRELBOTH(("vboxsf: Specified shared folder name is not zero terminated!\n"));
166	return -EINVAL;
167	}
168	if (RTStrNLen(info->nls_name, sizeof(info->nls_name)) >= sizeof(info->nls_name)) {
169	SFLOGRELBOTH(("vboxsf: Specified nls name is not zero terminated!\n"));
170	return -EINVAL;
171	}
172
173	/*
174	* Allocate memory.
175	*/
176	str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
177	str_name = kmalloc(str_len, GFP_KERNEL);
178	sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL);
179	if (sf_g && str_name) {
180	RT_ZERO(*sf_g);
181
182	str_name->u16Length = name_len;
183	str_name->u16Size = name_len + 1;
184	memcpy(str_name->String.utf8, info->name, name_len + 1);
185
186	/*
187	* Init the NLS support, if needed.
188	*/
189	rc = 0;
190	#define _IS_UTF8(_str) (strcmp(_str, "utf8") == 0)
191	#define _IS_EMPTY(_str) (strcmp(_str, "") == 0)
192
193	/* Check if NLS charset is valid and not points to UTF8 table */
194	sf_g->fNlsIsUtf8 = true;
195	if (info->nls_name[0]) {
196	if (_IS_UTF8(info->nls_name)) {
197	SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8\n"));
198	sf_g->nls = NULL;
199	} else {
200	sf_g->fNlsIsUtf8 = false;
201	sf_g->nls = load_nls(info->nls_name);
202	if (sf_g->nls) {
203	SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=%s -> %p\n", info->nls_name, sf_g->nls));
204	} else {
205	SFLOGRELBOTH(("vboxsf: Failed to load nls '%s'!\n", info->nls_name));
206	rc = -EINVAL;
207	}
208	}
209	} else {
210	#ifdef CONFIG_NLS_DEFAULT
211	/* If no NLS charset specified, try to load the default
212	* one if it's not points to UTF8. */
213	if (!_IS_UTF8(CONFIG_NLS_DEFAULT)
214	&& !_IS_EMPTY(CONFIG_NLS_DEFAULT)) {
215	sf_g->fNlsIsUtf8 = false;
216	sf_g->nls = load_nls_default();
217	SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: CONFIG_NLS_DEFAULT=%s -> %p\n", CONFIG_NLS_DEFAULT, sf_g->nls));
218	} else {
219	SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (default %s)\n", CONFIG_NLS_DEFAULT));
220	sf_g->nls = NULL;
221	}
222	#else
223	SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (no default)\n"));
224	sf_g->nls = NULL;
225	#endif
226	}
227	#undef _IS_UTF8
228	#undef _IS_EMPTY
229	if (rc == 0) {
230	/*
231	* Try mount it.
232	*/
233	rc = VbglR0SfHostReqMapFolderWithContigSimple(str_name, virt_to_phys(str_name), RTPATH_DELIMITER,
234	true /fCaseSensitive/, &sf_g->map.root);
235	if (RT_SUCCESS(rc)) {
236	kfree(str_name);
237
238	/* The rest is shared with remount. */
239	vbsf_super_info_copy_remount_options(sf_g, info);
240
241	*sf_gp = sf_g;
242	return 0;
243	}
244
245	/*
246	* bail out:
247	*/
248	if (rc == VERR_FILE_NOT_FOUND) {
249	LogRel(("vboxsf: SHFL_FN_MAP_FOLDER failed for '%s': share not found\n", info->name));
250	rc = -ENXIO;
251	} else {
252	LogRel(("vboxsf: SHFL_FN_MAP_FOLDER failed for '%s': %Rrc\n", info->name, rc));
253	rc = -EPROTO;
254	}
255	if (sf_g->nls)
256	unload_nls(sf_g->nls);
257	}
258	} else {
259	SFLOGRELBOTH(("vboxsf: Could not allocate memory for super info!\n"));
260	rc = -ENOMEM;
261	}
262	if (str_name)
263	kfree(str_name);
264	if (sf_g)
265	kfree(sf_g);
266	return rc;
267	}
268
269	/* unmap the share and free super info [sf_g] */
270	static void vbsf_super_info_free(struct vbsf_super_info *sf_g)
271	{
272	int rc;
273
274	TRACE();
275	rc = VbglR0SfHostReqUnmapFolderSimple(sf_g->map.root);
276	if (RT_FAILURE(rc))
277	LogFunc(("VbglR0SfHostReqUnmapFolderSimple failed rc=%Rrc\n", rc));
278
279	if (sf_g->nls)
280	unload_nls(sf_g->nls);
281
282	kfree(sf_g);
283	}
284
285
286	/**
287	* Initialize backing device related matters.
288	*/
289	static int vbsf_init_backing_dev(struct super_block sb, struct vbsf_super_info sf_g)
290	{
291	int rc = 0;
292	/** @todo this needs sorting out between 3.19 and 4.11 */
293	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
294	/* Each new shared folder map gets a new uint64_t identifier,
295	* allocated in sequence. We ASSUME the sequence will not wrap. */
296	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
297	static uint64_t s_u64Sequence = 0;
298	uint64_t u64CurrentSequence = ASMAtomicIncU64(&s_u64Sequence);
299	#endif
300	struct backing_dev_info *bdi;
301
302	# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
303	rc = super_setup_bdi_name(sb, "vboxsf-%llu", (unsigned long long)u64CurrentSequence);
304	if (!rc)
305	bdi = sb->s_bdi;
306	else
307	return rc;
308	# else
309	bdi = &sf_g->bdi;
310	# endif
311
312	bdi->ra_pages = 0; /* No readahead */
313
314	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
315	bdi->capabilities = 0
316	# ifdef BDI_CAP_MAP_DIRECT
317	\| BDI_CAP_MAP_DIRECT /* MAP_SHARED */
318	# endif
319	# ifdef BDI_CAP_MAP_COPY
320	\| BDI_CAP_MAP_COPY /* MAP_PRIVATE */
321	# endif
322	# ifdef BDI_CAP_READ_MAP
323	\| BDI_CAP_READ_MAP /* can be mapped for reading */
324	# endif
325	# ifdef BDI_CAP_WRITE_MAP
326	\| BDI_CAP_WRITE_MAP /* can be mapped for writing */
327	# endif
328	# ifdef BDI_CAP_EXEC_MAP
329	\| BDI_CAP_EXEC_MAP /* can be mapped for execution */
330	# endif
331	# ifdef BDI_CAP_STRICTLIMIT
332	# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) /* Trouble with 3.16.x/debian8. Process stops after dirty page throttling.
333	* Only tested successfully with 4.19. Maybe skip altogether? */
334	\| BDI_CAP_STRICTLIMIT;
335	# endif
336	# endif
337	;
338	# ifdef BDI_CAP_STRICTLIMIT
339	/* Smalles possible amount of dirty pages: %1 of RAM. We set this to
340	try reduce amount of data that's out of sync with the host side.
341	Besides, writepages isn't implemented, so flushing is extremely slow.
342	Note! Extremely slow linux 3.0.0 msync doesn't seem to be related to this setting. */
343	bdi_set_max_ratio(bdi, 1);
344	# endif
345	# endif /* >= 2.6.12 */
346
347	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE < KERNEL_VERSION(4, 11, 0)
348	rc = bdi_init(&sf_g->bdi);
349	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
350	if (!rc)
351	rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%llu", (unsigned long long)u64CurrentSequence);
352	# endif /* >= 2.6.26 */
353	# endif /* 4.11.0 > version >= 2.6.24 */
354	#endif /* >= 2.6.0 */
355	return rc;
356	}
357
358
359	/**
360	* Undoes what vbsf_init_backing_dev did.
361	*/
362	static void vbsf_done_backing_dev(struct super_block sb, struct vbsf_super_info sf_g)
363	{
364	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
365	bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */
366	#endif
367	}
368
369
370	/**
371	* Creates the root inode and attaches it to the super block.
372	*
373	* @returns 0 on success, negative errno on failure.
374	* @param sb The super block.
375	* @param sf_g Our super block info.
376	*/
377	static int vbsf_create_root_inode(struct super_block sb, struct vbsf_super_info sf_g)
378	{
379	SHFLFSOBJINFO fsinfo;
380	int rc;
381
382	/*
383	* Allocate and initialize the memory for our inode info structure.
384	*/
385	struct vbsf_inode_info sf_i = kmalloc(sizeof(sf_i), GFP_KERNEL);
386	SHFLSTRING *path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL);
387	if (sf_i && path) {
388	sf_i->handle = SHFL_HANDLE_NIL;
389	sf_i->force_restat = false;
390	RTListInit(&sf_i->HandleList);
391	#ifdef VBOX_STRICT
392	sf_i->u32Magic = SF_INODE_INFO_MAGIC;
393	#endif
394	sf_i->path = path;
395
396	path->u16Length = 1;
397	path->u16Size = 2;
398	path->String.utf8[0] = '/';
399	path->String.utf8[1] = 0;
400
401	/*
402	* Stat the root directory (for inode info).
403	*/
404	rc = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
405	if (rc == 0) {
406	/*
407	* Create the actual inode structure.
408	* Note! ls -la does display '.' and '..' entries with st_ino == 0, so root is #1.
409	*/
410	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
411	struct inode *iroot = iget_locked(sb, 1);
412	#else
413	struct inode *iroot = iget(sb, 1);
414	#endif
415	if (iroot) {
416	vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
417	VBSF_SET_INODE_INFO(iroot, sf_i);
418
419	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
420	unlock_new_inode(iroot);
421	#endif
422
423	/*
424	* Now make it a root inode.
425	*/
426	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
427	sb->s_root = d_make_root(iroot);
428	#else
429	sb->s_root = d_alloc_root(iroot);
430	#endif
431	if (sb->s_root) {
432
433	return 0;
434	}
435
436	SFLOGRELBOTH(("vboxsf: d_make_root failed!\n"));
437	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0) /* d_make_root calls iput */
438	iput(iroot);
439	#endif
440	/* iput() will call vbsf_evict_inode()/vbsf_clear_inode(). */
441	sf_i = NULL;
442	path = NULL;
443
444	rc = -ENOMEM;
445	} else {
446	SFLOGRELBOTH(("vboxsf: failed to allocate root inode!\n"));
447	rc = -ENOMEM;
448	}
449	} else
450	SFLOGRELBOTH(("vboxsf: could not stat root of share: %d\n", rc));
451	} else {
452	SFLOGRELBOTH(("vboxsf: Could not allocate memory for root inode info!\n"));
453	rc = -ENOMEM;
454	}
455	if (sf_i)
456	kfree(sf_i);
457	if (path)
458	kfree(path);
459	return rc;
460	}
461
462
463	/**
464	* This is called by vbsf_read_super_24() and vbsf_read_super_26() when vfs mounts
465	* the fs and wants to read super_block.
466	*
467	* Calls vbsf_super_info_alloc_and_map_it() to map the folder and allocate super
468	* information structure.
469	*
470	* Initializes @a sb, initializes root inode and dentry.
471	*
472	* Should respect @a flags.
473	*/
474	static int vbsf_read_super_aux(struct super_block sb, void data, int flags)
475	{
476	int rc;
477	struct vbsf_super_info *sf_g;
478
479	TRACE();
480	if (!data) {
481	SFLOGRELBOTH(("vboxsf: No mount data. Is mount.vboxsf installed (typically in /sbin)?\n"));
482	return -EINVAL;
483	}
484
485	if (flags & MS_REMOUNT) {
486	SFLOGRELBOTH(("vboxsf: Remounting is not supported!\n"));
487	return -ENOSYS;
488	}
489
490	/*
491	* Create our super info structure and map the shared folder.
492	*/
493	rc = vbsf_super_info_alloc_and_map_it((struct vbsf_mount_info_new *)data, &sf_g);
494	if (rc == 0) {
495	/*
496	* Initialize the super block structure (must be done before
497	* root inode creation).
498	*/
499	sb->s_magic = 0xface;
500	sb->s_blocksize = 1024;
501	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 3)
502	/* Required for seek/sendfile (see 'loff_t max' in fs/read_write.c / do_sendfile()). */
503	# if defined MAX_LFS_FILESIZE
504	sb->s_maxbytes = MAX_LFS_FILESIZE;
505	# elif BITS_PER_LONG == 32
506	sb->s_maxbytes = (loff_t)ULONG_MAX << PAGE_SHIFT;
507	# else
508	sb->s_maxbytes = INT64_MAX;
509	# endif
510	#endif
511	sb->s_op = &g_vbsf_super_ops;
512	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
513	sb->s_d_op = &vbsf_dentry_ops;
514	#endif
515
516	/*
517	* Initialize the backing device. This is important for memory mapped
518	* files among other things.
519	*/
520	rc = vbsf_init_backing_dev(sb, sf_g);
521	if (rc == 0) {
522	/*
523	* Create the root inode and we're done.
524	*/
525	rc = vbsf_create_root_inode(sb, sf_g);
526	if (rc == 0) {
527	VBSF_SET_SUPER_INFO(sb, sf_g);
528	SFLOGFLOW(("vbsf_read_super_aux: returns successfully\n"));
529	return 0;
530	}
531	vbsf_done_backing_dev(sb, sf_g);
532	} else
533	SFLOGRELBOTH(("vboxsf: backing device information initialization failed: %d\n", rc));
534	vbsf_super_info_free(sf_g);
535	}
536	return rc;
537	}
538
539
540	/**
541	* This is called when vfs is about to destroy the @a inode.
542	*
543	* We must free the inode info structure here.
544	*/
545	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
546	static void vbsf_evict_inode(struct inode *inode)
547	#else
548	static void vbsf_clear_inode(struct inode *inode)
549	#endif
550	{
551	struct vbsf_inode_info *sf_i;
552
553	TRACE();
554
555	/*
556	* Flush stuff.
557	*/
558	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
559	truncate_inode_pages(&inode->i_data, 0);
560	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
561	clear_inode(inode);
562	# else
563	end_writeback(inode);
564	# endif
565	#endif
566	/*
567	* Clean up our inode info.
568	*/
569	sf_i = VBSF_GET_INODE_INFO(inode);
570	if (sf_i) {
571	VBSF_SET_INODE_INFO(inode, NULL);
572
573	Assert(sf_i->u32Magic == SF_INODE_INFO_MAGIC);
574	BUG_ON(!sf_i->path);
575	kfree(sf_i->path);
576	vbsf_handle_drop_chain(sf_i);
577	# ifdef VBOX_STRICT
578	sf_i->u32Magic = SF_INODE_INFO_MAGIC_DEAD;
579	# endif
580	kfree(sf_i);
581	}
582	}
583
584
585	/* this is called by vfs when it wants to populate [inode] with data.
586	the only thing that is known about inode at this point is its index
587	hence we can't do anything here, and let lookup/whatever with the
588	job to properly fill then [inode] */
589	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
590	static void vbsf_read_inode(struct inode *inode)
591	{
592	}
593	#endif
594
595
596	/* vfs is done with [sb] (umount called) call [vbsf_super_info_free] to unmap
597	the folder and free [sf_g] */
598	static void vbsf_put_super(struct super_block *sb)
599	{
600	struct vbsf_super_info *sf_g;
601
602	sf_g = VBSF_GET_SUPER_INFO(sb);
603	BUG_ON(!sf_g);
604	vbsf_done_backing_dev(sb, sf_g);
605	vbsf_super_info_free(sf_g);
606	}
607
608
609	/**
610	* Get file system statistics.
611	*/
612	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
613	static int vbsf_statfs(struct dentry dentry, struct kstatfs stat)
614	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 73)
615	static int vbsf_statfs(struct super_block sb, struct kstatfs stat)
616	#else
617	static int vbsf_statfs(struct super_block sb, struct statfs stat)
618	#endif
619	{
620	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
621	struct super_block *sb = dentry->d_inode->i_sb;
622	#endif
623	int rc;
624	VBOXSFVOLINFOREQ pReq = (VBOXSFVOLINFOREQ )VbglR0PhysHeapAlloc(sizeof(*pReq));
625	if (pReq) {
626	SHFLVOLINFO *pVolInfo = &pReq->VolInfo;
627	struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(sb);
628	rc = VbglR0SfHostReqQueryVolInfo(sf_g->map.root, pReq, SHFL_HANDLE_ROOT);
629	if (RT_SUCCESS(rc)) {
630	stat->f_type = UINT32_C(0x786f4256); /* 'VBox' little endian */
631	stat->f_bsize = pVolInfo->ulBytesPerAllocationUnit;
632	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 73)
633	stat->f_frsize = pVolInfo->ulBytesPerAllocationUnit;
634	#endif
635	stat->f_blocks = pVolInfo->ullTotalAllocationBytes
636	/ pVolInfo->ulBytesPerAllocationUnit;
637	stat->f_bfree = pVolInfo->ullAvailableAllocationBytes
638	/ pVolInfo->ulBytesPerAllocationUnit;
639	stat->f_bavail = pVolInfo->ullAvailableAllocationBytes
640	/ pVolInfo->ulBytesPerAllocationUnit;
641	stat->f_files = 1000;
642	stat->f_ffree = 1000000; /* don't return 0 here since the guest may think
643	* that it is not possible to create any more files */
644	stat->f_fsid.val[0] = 0;
645	stat->f_fsid.val[1] = 0;
646	stat->f_namelen = 255;
647	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
648	stat->f_flags = 0; /* not valid */
649	#endif
650	RT_ZERO(stat->f_spare);
651	rc = 0;
652	} else
653	rc = -RTErrConvertToErrno(rc);
654	VbglR0PhysHeapFree(pReq);
655	} else
656	rc = -ENOMEM;
657	return rc;
658	}
659
660	static int vbsf_remount_fs(struct super_block sb, int flags, char *data)
661	{
662	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 23)
663	struct vbsf_super_info *sf_g;
664	struct vbsf_inode_info *sf_i;
665	struct inode *iroot;
666	SHFLFSOBJINFO fsinfo;
667	int err;
668
669	sf_g = VBSF_GET_SUPER_INFO(sb);
670	BUG_ON(!sf_g);
671	if (data && data[0] != 0) {
672	struct vbsf_mount_info_new info = (struct vbsf_mount_info_new )data;
673	if ( info->nullchar == '\0'
674	&& info->signature[0] == VBSF_MOUNT_SIGNATURE_BYTE_0
675	&& info->signature[1] == VBSF_MOUNT_SIGNATURE_BYTE_1
676	&& info->signature[2] == VBSF_MOUNT_SIGNATURE_BYTE_2) {
677	vbsf_super_info_copy_remount_options(sf_g, info);
678	}
679	}
680
681	iroot = ilookup(sb, 0);
682	if (!iroot)
683	return -ENOSYS;
684
685	sf_i = VBSF_GET_INODE_INFO(iroot);
686	err = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
687	BUG_ON(err != 0);
688	vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
689	/unlock_new_inode(iroot); /
690	return 0;
691	#else /* LINUX_VERSION_CODE < 2.4.23 */
692	return -ENOSYS;
693	#endif /* LINUX_VERSION_CODE < 2.4.23 */
694	}
695
696
697	/**
698	* Show mount options.
699	*
700	* This is needed by the VBoxService automounter in order for it to pick up
701	* the the 'tag' option value it sets on its mount.
702	*/
703	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
704	static int vbsf_show_options(struct seq_file m, struct vfsmount mnt)
705	#else
706	static int vbsf_show_options(struct seq_file m, struct dentry root)
707	#endif
708	{
709	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
710	struct super_block *sb = mnt->mnt_sb;
711	#else
712	struct super_block *sb = root->d_sb;
713	#endif
714	struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(sb);
715	if (sf_g) {
716	seq_printf(m, ",uid=%u,gid=%u,ttl=%d,maxiopages=%u,iocharset=%s",
717	sf_g->uid, sf_g->gid, sf_g->ttl_msec, sf_g->cMaxIoPages, sf_g->nls ? sf_g->nls->charset : "utf8");
718	if (sf_g->dmode != ~0)
719	seq_printf(m, ",dmode=0%o", sf_g->dmode);
720	if (sf_g->fmode != ~0)
721	seq_printf(m, ",fmode=0%o", sf_g->fmode);
722	if (sf_g->dmask != 0)
723	seq_printf(m, ",dmask=0%o", sf_g->dmask);
724	if (sf_g->fmask != 0)
725	seq_printf(m, ",fmask=0%o", sf_g->fmask);
726	if (sf_g->tag[0] != '\0') {
727	seq_puts(m, ",tag=");
728	seq_escape(m, sf_g->tag, " \t\n\\");
729	}
730	}
731	return 0;
732	}
733
734
735	/**
736	* Super block operations.
737	*/
738	static struct super_operations g_vbsf_super_ops = {
739	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
740	.clear_inode = vbsf_clear_inode,
741	#else
742	.evict_inode = vbsf_evict_inode,
743	#endif
744	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
745	.read_inode = vbsf_read_inode,
746	#endif
747	.put_super = vbsf_put_super,
748	.statfs = vbsf_statfs,
749	.remount_fs = vbsf_remount_fs,
750	.show_options = vbsf_show_options
751	};
752
753
754
755	/*********************************************************************************************************************************
756	* File system type related stuff. *
757	*********************************************************************************************************************************/
758
759	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 4)
760
761	static int vbsf_read_super_26(struct super_block sb, void data, int flags)
762	{
763	int err;
764
765	TRACE();
766	err = vbsf_read_super_aux(sb, data, flags);
767	if (err)
768	printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
769
770	return err;
771	}
772
773	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
774	static struct super_block vbsf_get_sb(struct file_system_type fs_type, int flags, const char dev_name, void data)
775	{
776	TRACE();
777	return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26);
778	}
779	# elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
780	static int vbsf_get_sb(struct file_system_type fs_type, int flags, const char dev_name, void data, struct vfsmount mnt)
781	{
782	TRACE();
783	return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26, mnt);
784	}
785	# else /* LINUX_VERSION_CODE >= 2.6.39 */
786	static struct dentry sf_mount(struct file_system_type fs_type, int flags, const char dev_name, void data)
787	{
788	TRACE();
789	return mount_nodev(fs_type, flags, data, vbsf_read_super_26);
790	}
791	# endif /* LINUX_VERSION_CODE >= 2.6.39 */
792
793	/**
794	* File system registration structure.
795	*/
796	static struct file_system_type g_vboxsf_fs_type = {
797	.owner = THIS_MODULE,
798	.name = "vboxsf",
799	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
800	.get_sb = vbsf_get_sb,
801	# else
802	.mount = sf_mount,
803	# endif
804	.kill_sb = kill_anon_super
805	};
806
807	#else /* LINUX_VERSION_CODE < 2.5.4 */
808
809	static struct super_block vbsf_read_super_24(struct super_block sb, void *data, int flags)
810	{
811	int err;
812
813	TRACE();
814	err = vbsf_read_super_aux(sb, data, flags);
815	if (err) {
816	printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
817	return NULL;
818	}
819
820	return sb;
821	}
822
823	static DECLARE_FSTYPE(g_vboxsf_fs_type, "vboxsf", vbsf_read_super_24, 0);
824
825	#endif /* LINUX_VERSION_CODE < 2.5.4 */
826
827
828
829	/*********************************************************************************************************************************
830	* Module stuff *
831	*********************************************************************************************************************************/
832
833	/**
834	* Called on module initialization.
835	*/
836	static int __init init(void)
837	{
838	int rc;
839	SFLOGFLOW(("vboxsf: init\n"));
840
841	/*
842	* Must be paranoid about the vbsf_mount_info_new size.
843	*/
844	AssertCompile(sizeof(struct vbsf_mount_info_new) <= PAGE_SIZE);
845	if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE) {
846	printk(KERN_ERR
847	"vboxsf: Mount information structure is too large %lu\n"
848	"vboxsf: Must be less than or equal to %lu\n",
849	(unsigned long)sizeof(struct vbsf_mount_info_new),
850	(unsigned long)PAGE_SIZE);
851	return -EINVAL;
852	}
853
854	/*
855	* Initialize stuff.
856	*/
857	spin_lock_init(&g_SfHandleLock);
858	rc = VbglR0SfInit();
859	if (RT_SUCCESS(rc)) {
860	/*
861	* Try connect to the shared folder HGCM service.
862	* It is possible it is not there.
863	*/
864	rc = VbglR0SfConnect(&g_SfClient);
865	if (RT_SUCCESS(rc)) {
866	/*
867	* Query host HGCM features and afterwards (must be last) shared folder features.
868	*/
869	rc = VbglR0QueryHostFeatures(&g_fHostFeatures);
870	if (RT_FAILURE(rc))
871	{
872	LogRel(("vboxsf: VbglR0QueryHostFeatures failed: rc=%Rrc (ignored)\n", rc));
873	g_fHostFeatures = 0;
874	}
875	VbglR0SfHostReqQueryFeaturesSimple(&g_fSfFeatures, &g_uSfLastFunction);
876	LogRel(("vboxsf: g_fHostFeatures=%#x g_fSfFeatures=%#RX64 g_uSfLastFunction=%u\n",
877	g_fHostFeatures, g_fSfFeatures, g_uSfLastFunction));
878
879	/*
880	* Tell the shared folder service about our expectations:
881	* - UTF-8 strings (rather than UTF-16)
882	* - Wheter to return or follow (default) symbolic links.
883	*/
884	rc = VbglR0SfHostReqSetUtf8Simple();
885	if (RT_SUCCESS(rc)) {
886	if (!g_fFollowSymlinks) {
887	rc = VbglR0SfHostReqSetSymlinksSimple();
888	if (RT_FAILURE(rc))
889	printk(KERN_WARNING "vboxsf: Host unable to enable showing symlinks, rc=%d\n", rc);
890	}
891	/*
892	* Now that we're ready for action, try register the
893	* file system with the kernel.
894	*/
895	rc = register_filesystem(&g_vboxsf_fs_type);
896	if (rc == 0) {
897	printk(KERN_INFO "vboxsf: Successfully loaded version " VBOX_VERSION_STRING "\n");
898	return 0;
899	}
900
901	/*
902	* Failed. Bail out.
903	*/
904	LogRel(("vboxsf: register_filesystem failed: rc=%d\n", rc));
905	} else {
906	LogRel(("vboxsf: VbglR0SfSetUtf8 failed, rc=%Rrc\n", rc));
907	rc = -EPROTO;
908	}
909	VbglR0SfDisconnect(&g_SfClient);
910	} else {
911	LogRel(("vboxsf: VbglR0SfConnect failed, rc=%Rrc\n", rc));
912	rc = rc == VERR_HGCM_SERVICE_NOT_FOUND ? -EHOSTDOWN : -ECONNREFUSED;
913	}
914	VbglR0SfTerm();
915	} else {
916	LogRel(("vboxsf: VbglR0SfInit failed, rc=%Rrc\n", rc));
917	rc = -EPROTO;
918	}
919	return rc;
920	}
921
922
923	/**
924	* Called on module finalization.
925	*/
926	static void __exit fini(void)
927	{
928	SFLOGFLOW(("vboxsf: fini\n"));
929
930	unregister_filesystem(&g_vboxsf_fs_type);
931	VbglR0SfDisconnect(&g_SfClient);
932	VbglR0SfTerm();
933	}
934
935
936	/*
937	* Module parameters.
938	*/
939	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 52)
940	module_param_named(follow_symlinks, g_fFollowSymlinks, int, 0);
941	MODULE_PARM_DESC(follow_symlinks,
942	"Let host resolve symlinks rather than showing them");
943	#endif
944
945
946	/*
947	* Module declaration related bits.
948	*/
949	module_init(init);
950	module_exit(fini);
951
952	MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access");
953	MODULE_AUTHOR(VBOX_VENDOR);
954	MODULE_LICENSE("GPL and additional rights");
955	#ifdef MODULE_ALIAS_FS
956	MODULE_ALIAS_FS("vboxsf");
957	#endif
958	#ifdef MODULE_VERSION
959	MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV));
960	#endif
961

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

source: vbox/trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c@ 77944

Download in other formats: