vboxsf.c@ 101702

Last change on this file since 101702 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.3 KB

Line
1	/* $Id: vboxsf.c 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* Shared folders - Haiku Guest Additions, implementation.
4	*/
5
6	/*
7	* Copyright (C) 2012-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	/*
29	* This code is based on:
30	*
31	* VirtualBox Guest Additions for Haiku.
32	* Copyright (c) 2011 Mike Smith <[email protected]>
33	*
34	* Permission is hereby granted, free of charge, to any person
35	* obtaining a copy of this software and associated documentation
36	* files (the "Software"), to deal in the Software without
37	* restriction, including without limitation the rights to use,
38	* copy, modify, merge, publish, distribute, sublicense, and/or sell
39	* copies of the Software, and to permit persons to whom the
40	* Software is furnished to do so, subject to the following
41	* conditions:
42	*
43	* The above copyright notice and this permission notice shall be
44	* included in all copies or substantial portions of the Software.
45	*
46	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
47	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
48	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
49	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
50	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
51	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
52	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
53	* OTHER DEALINGS IN THE SOFTWARE.
54	*/
55
56	#include "vboxsf.h"
57
58	#define MODULE_NAME "file_systems/vboxsf"
59	#define FS_NAME "vboxsf"
60	#define FS_PRETTY_NAME "VirtualBox Shared Folders"
61
62	VBGLSFCLIENT g_clientHandle;
63	static fs_volume_ops vboxsf_volume_ops;
64	static fs_vnode_ops vboxsf_vnode_ops;
65
66	status_t init_module(void)
67	{
68	#if 0
69	/** @todo enable this soon */
70	int rc = get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest);
71	if (RT_LIKELY(rc == B_OK)
72	{
73	rc = VbglR0SfInit();
74	if (RT_SUCCESS(rc))
75	{
76	rc = VbglR0SfConnect(&g_clientHandle);
77	if (RT_SUCCESS(rc))
78	{
79	rc = VbglR0SfSetUtf8(&g_clientHandle);
80	if (RT_SUCCESS(rc))
81	{
82	rc = VbglR0SfSetSymlinks(&g_clientHandle);
83	if (RT_FAILURE(rc))
84	LogRel((FS_NAME ": Warning! VbglR0SfSetSymlinks failed (rc=%d) - symlink will appear as copies.\n", rc));
85
86	mutex_init(&g_vnodeCacheLock, "vboxsf vnode cache lock");
87	Log((FS_NAME ": init_module succeeded.\n");
88	return B_OK;
89	}
90	else
91	LogRel((FS_NAME ": VbglR0SfSetUtf8 failed. rc=%d\n", rc));
92	}
93	else
94	LogRel((FS_NAME ": VbglR0SfConnect failed. rc=%d\n", rc));
95	}
96	else
97	LogRel((FS_NAME ": VbglR0SfInit failed. rc=%d\n", rc));
98	}
99	else
100	LogRel((FS_NAME ": get_module failed for '%s'. rc=%d\n", VBOXGUEST_MODULE_NAME, rc));
101
102	return B_ERROR;
103	#endif
104
105	if (get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest) != B_OK)
106	{
107	dprintf("get_module(%s) failed\n", VBOXGUEST_MODULE_NAME);
108	return B_ERROR;
109	}
110
111	if (RT_FAILURE(VbglR0SfInit()))
112	{
113	dprintf("VbglR0SfInit failed\n");
114	return B_ERROR;
115	}
116
117	if (RT_FAILURE(VbglR0SfConnect(&g_clientHandle)))
118	{
119	dprintf("VbglR0SfConnect failed\n");
120	return B_ERROR;
121	}
122
123	if (RT_FAILURE(VbglR0SfSetUtf8(&g_clientHandle)))
124	{
125	dprintf("VbglR0SfSetUtf8 failed\n");
126	return B_ERROR;
127	}
128
129	if (RT_FAILURE(VbglR0SfSetSymlinks(&g_clientHandle)))
130	{
131	dprintf("warning: VbglR0SfSetSymlinks failed (old vbox?) - symlinks will appear as copies\n");
132	}
133
134	mutex_init(&g_vnodeCacheLock, "vboxsf vnode cache lock");
135
136	dprintf(FS_NAME ": inited successfully\n");
137	return B_OK;
138	}
139
140	void uninit_module(void)
141	{
142	mutex_destroy(&g_vnodeCacheLock);
143	put_module(VBOXGUEST_MODULE_NAME);
144	}
145
146
147	PSHFLSTRING make_shflstring(const char* const s)
148	{
149	int len = strlen(s);
150	if (len > 0xFFFE)
151	{
152	dprintf(FS_NAME ": make_shflstring: string too long\n");
153	return NULL;
154	}
155
156	PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
157	if (!rv)
158	return NULL;
159
160	rv->u16Length = len;
161	rv->u16Size = len + 1;
162	strcpy(rv->String.utf8, s);
163	return rv;
164	}
165
166
167	PSHFLSTRING clone_shflstring(PSHFLSTRING s)
168	{
169	PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s->u16Length);
170	if (rv)
171	memcpy(rv, s, sizeof(SHFLSTRING) + s->u16Length);
172	return rv;
173	}
174
175	PSHFLSTRING concat_shflstring_cstr(PSHFLSTRING s1, const char* const s2)
176	{
177	size_t s2len = strlen(s2);
178	PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1->u16Length + s2len);
179	if (rv)
180	{
181	memcpy(rv, s1, sizeof(SHFLSTRING) + s1->u16Length);
182	strcat(rv->String.utf8, s2);
183	rv->u16Length += s2len;
184	rv->u16Size += s2len;
185	}
186	return rv;
187	}
188
189
190	PSHFLSTRING concat_cstr_shflstring(const char* const s1, PSHFLSTRING s2)
191	{
192	size_t s1len = strlen(s1);
193	PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1len + s2->u16Length);
194	if (rv)
195	{
196	strcpy(rv->String.utf8, s1);
197	strcat(rv->String.utf8, s2->String.utf8);
198	rv->u16Length = s1len + s2->u16Length;
199	rv->u16Size = rv->u16Length + 1;
200	}
201	return rv;
202	}
203
204
205	PSHFLSTRING build_path(vboxsf_vnode* dir, const char* const name)
206	{
207	dprintf("*** build_path(%p, %p)\n", dir, name);
208	if (!dir \|\| !name)
209	return NULL;
210
211	size_t len = dir->path->u16Length + strlen(name) + 1;
212	PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
213	if (rv)
214	{
215	strcpy(rv->String.utf8, dir->path->String.utf8);
216	strcat(rv->String.utf8, "/");
217	strcat(rv->String.utf8, name);
218	rv->u16Length = len;
219	rv->u16Size = rv->u16Length + 1;
220	}
221	return rv;
222	}
223
224
225	status_t mount(fs_volume volume, const char device, uint32 flags, const char args, ino_t _rootVnodeID)
226	{
227	if (device)
228	{
229	dprintf(FS_NAME ": trying to mount a real device as a vbox share is silly\n");
230	return B_BAD_TYPE;
231	}
232
233	dprintf(FS_NAME ": mount(%s)\n", args);
234
235	PSHFLSTRING sharename = make_shflstring(args);
236
237	vboxsf_volume* vbsfvolume = malloc(sizeof(vboxsf_volume));
238	volume->private_volume = vbsfvolume;
239	int rv = VbglR0SfMapFolder(&g_clientHandle, sharename, &(vbsfvolume->map));
240	free(sharename);
241
242	if (rv == 0)
243	{
244	vboxsf_vnode* root_vnode;
245
246	PSHFLSTRING name = make_shflstring("");
247	if (!name)
248	{
249	dprintf(FS_NAME ": make_shflstring() failed\n");
250	return B_NO_MEMORY;
251	}
252
253	status_t rs = vboxsf_new_vnode(&vbsfvolume->map, name, name, &root_vnode);
254	dprintf(FS_NAME ": allocated %p (path=%p name=%p)\n", root_vnode, root_vnode->path, root_vnode->name);
255
256	if (rs != B_OK)
257	{
258	dprintf(FS_NAME ": vboxsf_new_vnode() failed (%d)\n", (int)rs);
259	return rs;
260	}
261
262	rs = publish_vnode(volume, root_vnode->vnode, root_vnode, &vboxsf_vnode_ops, S_IFDIR, 0);
263	dprintf(FS_NAME ": publish_vnode(): %d\n", (int)rs);
264	*_rootVnodeID = root_vnode->vnode;
265	volume->ops = &vboxsf_volume_ops;
266	return B_OK;
267	}
268	else
269	{
270	dprintf(FS_NAME ": VbglR0SfMapFolder failed (%d)\n", rv);
271	free(volume->private_volume);
272	return vbox_err_to_haiku_err(rv);
273	}
274	}
275
276
277	status_t unmount(fs_volume *volume)
278	{
279	dprintf(FS_NAME ": unmount\n");
280	VbglR0SfUnmapFolder(&g_clientHandle, volume->private_volume);
281	return B_OK;
282	}
283
284
285	status_t vboxsf_read_stat(fs_volume* _volume, fs_vnode* _vnode, struct stat* st)
286	{
287	vboxsf_vnode* vnode = _vnode->private_node;
288	vboxsf_volume* volume = _volume->private_volume;
289	SHFLCREATEPARMS params;
290	int rc;
291
292	dprintf("vboxsf_read_stat (_vnode=%p, vnode=%p, path=%p (%s))\n", _vnode, vnode, vnode->path->String.utf8, vnode->path->String.utf8);
293
294	params.Handle = SHFL_HANDLE_NIL;
295	params.CreateFlags = SHFL_CF_LOOKUP \| SHFL_CF_ACT_FAIL_IF_NEW;
296	dprintf("sf_stat: calling VbglR0SfCreate, file %s, flags %x\n", vnode->path->String.utf8, params.CreateFlags);
297	rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
298	if (rc == VERR_INVALID_NAME)
299	{
300	/* this can happen for names like 'foo' on a Windows host /
301	return B_ENTRY_NOT_FOUND;
302	}
303	if (RT_FAILURE(rc))
304	{
305	dprintf("VbglR0SfCreate: %d\n", params.Result);
306	return vbox_err_to_haiku_err(params.Result);
307	}
308	if (params.Result != SHFL_FILE_EXISTS)
309	{
310	dprintf("VbglR0SfCreate: %d\n", params.Result);
311	return B_ENTRY_NOT_FOUND;
312	}
313
314	st->st_dev = 0;
315	st->st_ino = vnode->vnode;
316	st->st_mode = mode_from_fmode(params.Info.Attr.fMode);
317	st->st_nlink = 1;
318	st->st_uid = 0;
319	st->st_gid = 0;
320	st->st_rdev = 0;
321	st->st_size = params.Info.cbObject;
322	st->st_blksize = 1;
323	st->st_blocks = params.Info.cbAllocated;
324	st->st_atime = RTTimeSpecGetSeconds(&params.Info.AccessTime);
325	st->st_mtime = RTTimeSpecGetSeconds(&params.Info.ModificationTime);
326	st->st_ctime = RTTimeSpecGetSeconds(&params.Info.BirthTime);
327	return B_OK;
328	}
329
330
331	status_t vboxsf_open_dir(fs_volume* _volume, fs_vnode* _vnode, void** _cookie)
332	{
333	vboxsf_volume* volume = _volume->private_volume;
334	vboxsf_vnode* vnode = _vnode->private_node;
335	SHFLCREATEPARMS params;
336
337	RT_ZERO(params);
338	params.Handle = SHFL_HANDLE_NIL;
339	params.CreateFlags = SHFL_CF_DIRECTORY \| SHFL_CF_ACT_OPEN_IF_EXISTS \| SHFL_CF_ACT_FAIL_IF_NEW \| SHFL_CF_ACCESS_READ;
340
341	int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
342	if (RT_SUCCESS(rc))
343	{
344	if (params.Result == SHFL_FILE_EXISTS && params.Handle != SHFL_HANDLE_NIL)
345	{
346	vboxsf_dir_cookie* cookie = malloc(sizeof(vboxsf_dir_cookie));
347	*_cookie = cookie;
348	cookie->index = 0;
349	cookie->path = build_path(vnode, "*");
350	cookie->handle = params.Handle;
351	cookie->has_more_files = true;
352	cookie->buffer_start = cookie->buffer = NULL;
353	cookie->buffer_length = cookie->num_files = 0;
354	return B_OK;
355	}
356	else
357	return B_ENTRY_NOT_FOUND;
358	}
359	else
360	{
361	dprintf(FS_NAME ": VbglR0SfCreate: %d\n", rc);
362	return vbox_err_to_haiku_err(rc);
363	}
364	}
365
366
367	/** read a single entry from a dir */
368	status_t vboxsf_read_dir_1(vboxsf_volume* volume, vboxsf_vnode* vnode, vboxsf_dir_cookie* cookie,
369	struct dirent* buffer, size_t bufferSize)
370	{
371	dprintf("%p, %d, %p\n", cookie, cookie->has_more_files, cookie->buffer);
372	if (!cookie->has_more_files)
373	return B_ENTRY_NOT_FOUND;
374
375	if (!cookie->buffer)
376	{
377	cookie->buffer_length = 16384;
378	cookie->buffer_start = cookie->buffer = malloc(cookie->buffer_length);
379
380	int rc = VbglR0SfDirInfo(&g_clientHandle, &volume->map, cookie->handle, cookie->path, 0, cookie->index,
381	&cookie->buffer_length, cookie->buffer, &cookie->num_files);
382
383	if (rc != 0 && rc != VERR_NO_MORE_FILES)
384	{
385	dprintf(FS_NAME ": VbglR0SfDirInfo failed: %d\n", rc);
386	free(cookie->buffer_start);
387	cookie->buffer_start = NULL;
388	return vbox_err_to_haiku_err(rc);
389	}
390
391	if (rc == VERR_NO_MORE_FILES)
392	{
393	free(cookie->buffer_start);
394	cookie->buffer_start = NULL;
395	cookie->has_more_files = false;
396	return B_ENTRY_NOT_FOUND;
397	}
398	}
399
400	if (bufferSize <= sizeof(struct dirent) + cookie->buffer->name.u16Length)
401	{
402	dprintf("hit end of buffer\n");
403	return B_BUFFER_OVERFLOW;
404	}
405
406	PSHFLSTRING name1 = clone_shflstring(&cookie->buffer->name);
407	if (!name1)
408	{
409	dprintf(FS_NAME ": make_shflstring() failed\n");
410	return B_NO_MEMORY;
411	}
412
413	vboxsf_vnode* new_vnode;
414	int rv = vboxsf_new_vnode(&volume->map, build_path(vnode, name1->String.utf8), name1, &new_vnode);
415	if (rv != B_OK)
416	{
417	dprintf(FS_NAME ": vboxsf_new_vnode() failed\n");
418	return rv;
419	}
420
421	buffer->d_dev = 0;
422	buffer->d_pdev = 0;
423	buffer->d_ino = new_vnode->vnode;
424	buffer->d_pino = vnode->vnode;
425	buffer->d_reclen = sizeof(struct dirent) + cookie->buffer->name.u16Length;
426	strncpy(buffer->d_name, cookie->buffer->name.String.utf8, NAME_MAX);
427
428	size_t size = offsetof(SHFLDIRINFO, name.String) + cookie->buffer->name.u16Size;
429	cookie->buffer = ((void*)cookie->buffer + size);
430	cookie->index++;
431
432	if (cookie->index >= cookie->num_files)
433	{
434	// hit end of this buffer, next call will reallocate a new one
435	free(cookie->buffer_start);
436	cookie->buffer_start = cookie->buffer = NULL;
437	}
438	return B_OK;
439	}
440
441
442	status_t vboxsf_read_dir(fs_volume* _volume, fs_vnode* _vnode, void* _cookie,
443	struct dirent* buffer, size_t bufferSize, uint32* _num)
444	{
445	vboxsf_dir_cookie* cookie = _cookie;
446	vboxsf_volume* volume = _volume->private_volume;
447	vboxsf_vnode* vnode = _vnode->private_node;
448	uint32 num_read = 0;
449	status_t rv = B_OK;
450
451	for (num_read = 0; num_read < *_num && cookie->has_more_files; num_read++)
452	{
453	rv = vboxsf_read_dir_1(volume, vnode, cookie, buffer, bufferSize);
454	if (rv == B_BUFFER_OVERFLOW \|\| rv == B_ENTRY_NOT_FOUND)
455	{
456	// hit end of at least one of the buffers - not really an error
457	rv = B_OK;
458	break;
459	}
460	bufferSize -= buffer->d_reclen;
461	buffer = ((void*)(buffer)) + buffer->d_reclen;
462	}
463
464	*_num = num_read;
465	return rv;
466	}
467
468
469	status_t vboxsf_free_dir_cookie(fs_volume* _volume, fs_vnode* vnode, void* _cookie)
470	{
471	vboxsf_volume* volume = _volume->private_volume;
472	vboxsf_dir_cookie* cookie = _cookie;
473
474	VbglR0SfClose(&g_clientHandle, &volume->map, cookie->handle);
475	free(cookie->path);
476	free(cookie);
477
478	return B_OK;
479	}
480
481
482	status_t vboxsf_read_fs_info(fs_volume* _volume, struct fs_info* info)
483	{
484	vboxsf_volume* volume = _volume->private_volume;
485
486	SHFLVOLINFO volume_info;
487	uint32_t bytes = sizeof(SHFLVOLINFO);
488
489	int rc = VbglR0SfFsInfo(&g_clientHandle, &volume->map, 0, SHFL_INFO_GET \| SHFL_INFO_VOLUME,
490	&bytes, (PSHFLDIRINFO)&volume_info);
491	if (RT_FAILURE(rc))
492	{
493	dprintf(FS_NAME ": VbglR0SfFsInfo failed (%d)\n", rc);
494	return vbox_err_to_haiku_err(rc);
495	}
496
497	info->flags = B_FS_IS_PERSISTENT;
498	if (volume_info.fsProperties.fReadOnly)
499	info->flags \|= B_FS_IS_READONLY;
500
501	info->dev = 0;
502	info->root = 1;
503	info->block_size = volume_info.ulBytesPerAllocationUnit;
504	info->io_size = volume_info.ulBytesPerAllocationUnit;
505	info->total_blocks = volume_info.ullTotalAllocationBytes / info->block_size;
506	info->free_blocks = volume_info.ullAvailableAllocationBytes / info->block_size;
507	info->total_nodes = LONGLONG_MAX;
508	info->free_nodes = LONGLONG_MAX;
509	strcpy(info->volume_name, "VBox share");
510	return B_OK;
511	}
512
513
514	status_t vboxsf_lookup(fs_volume* _volume, fs_vnode* dir, const char* name, ino_t* _id)
515	{
516	dprintf(FS_NAME ": lookup %s\n", name);
517	vboxsf_volume* volume = _volume->private_volume;
518	SHFLCREATEPARMS params;
519
520	RT_ZERO(params);
521	params.Handle = SHFL_HANDLE_NIL;
522	params.CreateFlags = SHFL_CF_LOOKUP \| SHFL_CF_ACT_FAIL_IF_NEW;
523
524	PSHFLSTRING path = build_path(dir->private_node, name);
525	if (!path)
526	{
527	dprintf(FS_NAME ": make_shflstring() failed\n");
528	return B_NO_MEMORY;
529	}
530
531	int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
532	if (RT_SUCCESS(rc))
533	{
534	if (params.Result == SHFL_FILE_EXISTS)
535	{
536	vboxsf_vnode* vn;
537	status_t rv = vboxsf_new_vnode(&volume->map, path, path, &vn);
538	if (rv == B_OK)
539	{
540	*_id = vn->vnode;
541	rv = publish_vnode(_volume, vn->vnode, vn, &vboxsf_vnode_ops, mode_from_fmode(params.Info.Attr.fMode), 0);
542	}
543	return rv;
544	}
545	else
546	{
547	free(path);
548	return B_ENTRY_NOT_FOUND;
549	}
550	}
551	else
552	{
553	free(path);
554	dprintf(FS_NAME ": VbglR0SfCreate: %d\n", rc);
555	return vbox_err_to_haiku_err(rc);
556	}
557	}
558
559
560	mode_t mode_from_fmode(RTFMODE fMode)
561	{
562	mode_t m = 0;
563
564	if (RTFS_IS_DIRECTORY(fMode))
565	m \|= S_IFDIR;
566	else if (RTFS_IS_FILE(fMode))
567	m \|= S_IFREG;
568	else if (RTFS_IS_FIFO(fMode))
569	m \|= S_IFIFO;
570	else if (RTFS_IS_DEV_CHAR(fMode))
571	m \|= S_IFCHR;
572	else if (RTFS_IS_DEV_BLOCK(fMode))
573	m \|= S_IFBLK;
574	else if (RTFS_IS_SYMLINK(fMode))
575	m \|= S_IFLNK;
576	else if (RTFS_IS_SOCKET(fMode))
577	m \|= S_IFSOCK;
578
579	if (fMode & RTFS_UNIX_IRUSR)
580	m \|= S_IRUSR;
581	if (fMode & RTFS_UNIX_IWUSR)
582	m \|= S_IWUSR;
583	if (fMode & RTFS_UNIX_IXUSR)
584	m \|= S_IXUSR;
585	if (fMode & RTFS_UNIX_IRGRP)
586	m \|= S_IRGRP;
587	if (fMode & RTFS_UNIX_IWGRP)
588	m \|= S_IWGRP;
589	if (fMode & RTFS_UNIX_IXGRP)
590	m \|= S_IXGRP;
591	if (fMode & RTFS_UNIX_IROTH)
592	m \|= S_IROTH;
593	if (fMode & RTFS_UNIX_IWOTH)
594	m \|= S_IWOTH;
595	if (fMode & RTFS_UNIX_IXOTH)
596	m \|= S_IXOTH;
597	if (fMode & RTFS_UNIX_ISUID)
598	m \|= S_ISUID;
599	if (fMode & RTFS_UNIX_ISGID)
600	m \|= S_ISGID;
601	if (fMode & RTFS_UNIX_ISTXT)
602	m \|= S_ISVTX;
603
604	return m;
605	}
606
607
608	status_t vboxsf_open(fs_volume* _volume, fs_vnode* _vnode, int openMode, void** _cookie)
609	{
610	vboxsf_volume* volume = _volume->private_volume;
611	vboxsf_vnode* vnode = _vnode->private_node;
612
613	dprintf(FS_NAME ": open %s (mode=%x)\n", vnode->path->String.utf8, openMode);
614
615	SHFLCREATEPARMS params;
616
617	RT_ZERO(params);
618	params.Handle = SHFL_HANDLE_NIL;
619
620	if (openMode & O_RDWR)
621	params.CreateFlags \|= SHFL_CF_ACCESS_READWRITE;
622	else if (openMode & O_RDONLY)
623	params.CreateFlags \|= SHFL_CF_ACCESS_READ;
624	else if (openMode & O_WRONLY)
625	params.CreateFlags \|= SHFL_CF_ACCESS_WRITE;
626
627	if (openMode & O_APPEND)
628	params.CreateFlags \|= SHFL_CF_ACCESS_APPEND;
629
630	if (openMode & O_CREAT)
631	{
632	params.CreateFlags \|= SHFL_CF_ACT_CREATE_IF_NEW;
633	if (openMode & O_EXCL)
634	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_EXISTS;
635	else if (openMode & O_TRUNC)
636	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
637	else
638	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
639	}
640	else
641	{
642	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_NEW;
643	if (openMode & O_TRUNC)
644	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
645	else
646	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
647	}
648
649	int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
650	if (!RT_SUCCESS(rc))
651	{
652	dprintf("VbglR0SfCreate returned %d\n", rc);
653	return vbox_err_to_haiku_err(rc);
654	}
655
656	vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
657	if (!cookie)
658	{
659	dprintf("couldn't allocate file cookie\n");
660	return B_NO_MEMORY;
661	}
662
663	cookie->handle = params.Handle;
664	cookie->path = vnode->path;
665
666	*_cookie = cookie;
667
668	return B_OK;
669	}
670
671
672	status_t vboxsf_create(fs_volume* _volume, fs_vnode* _dir, const char name, int openMode, int perms, void _cookie, ino_t _newVnodeID)
673	{
674	vboxsf_volume* volume = _volume->private_volume;
675
676	SHFLCREATEPARMS params;
677
678	RT_ZERO(params);
679	params.Handle = SHFL_HANDLE_NIL;
680
681	if (openMode & O_RDWR)
682	params.CreateFlags \|= SHFL_CF_ACCESS_READWRITE;
683	else if (openMode & O_RDONLY)
684	params.CreateFlags \|= SHFL_CF_ACCESS_READ;
685	else if (openMode & O_WRONLY)
686	params.CreateFlags \|= SHFL_CF_ACCESS_WRITE;
687
688	if (openMode & O_APPEND)
689	params.CreateFlags \|= SHFL_CF_ACCESS_APPEND;
690
691	if (openMode & O_CREAT)
692	{
693	params.CreateFlags \|= SHFL_CF_ACT_CREATE_IF_NEW;
694	if (openMode & O_EXCL)
695	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_EXISTS;
696	else if (openMode & O_TRUNC)
697	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
698	else
699	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
700	}
701	else
702	{
703	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_NEW;
704	if (openMode & O_TRUNC)
705	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
706	else
707	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
708	}
709
710	PSHFLSTRING path = build_path(_dir->private_node, name);
711	int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
712
713	if (!RT_SUCCESS(rc))
714	{
715	dprintf("VbglR0SfCreate returned %d\n", rc);
716	free(path);
717	return vbox_err_to_haiku_err(rc);
718	}
719
720	vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
721	if (!cookie)
722	{
723	dprintf("couldn't allocate file cookie\n");
724	free(path);
725	return B_NO_MEMORY;
726	}
727
728	cookie->handle = params.Handle;
729	cookie->path = path;
730
731	*_cookie = cookie;
732	return vboxsf_lookup(_volume, _dir, name, _newVnodeID);
733	}
734
735
736	status_t vboxsf_close(fs_volume* _volume, fs_vnode* _vnode, void* _cookie)
737	{
738	vboxsf_volume* volume = _volume->private_volume;
739	vboxsf_file_cookie* cookie = _cookie;
740
741	int rc = VbglR0SfClose(&g_clientHandle, &volume->map, cookie->handle);
742	dprintf("VbglR0SfClose returned %d\n", rc);
743	return vbox_err_to_haiku_err(rc);
744	}
745
746
747	status_t vboxsf_rewind_dir(fs_volume* _volume, fs_vnode* _vnode, void* _cookie)
748	{
749	vboxsf_dir_cookie* cookie = _cookie;
750	cookie->index = 0;
751	return B_OK;
752	}
753
754
755	status_t vboxsf_close_dir(fs_volume volume, fs_vnode vnode, void *cookie)
756	{
757	return B_OK;
758	}
759
760
761	status_t vboxsf_free_cookie(fs_volume volume, fs_vnode vnode, void *_cookie)
762	{
763	vboxsf_dir_cookie* cookie = _cookie;
764	free(cookie);
765	return B_OK;
766	}
767
768	status_t vboxsf_read(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, void buffer, size_t length)
769	{
770	vboxsf_volume* volume = _volume->private_volume;
771	vboxsf_vnode* vnode = _vnode->private_node;
772	vboxsf_file_cookie* cookie = _cookie;
773
774	if (*length > 0xFFFFFFFF)
775	*length = 0xFFFFFFFF;
776
777	uint32_t l = *length;
778	void* other_buffer = malloc(l); /** @todo map the user memory into kernel space here for efficiency */
779	int rc = VbglR0SfRead(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false /fLocked/);
780	memcpy(buffer, other_buffer, l);
781	free(other_buffer);
782
783	dprintf("VbglR0SfRead returned %d\n", rc);
784	*length = l;
785	return vbox_err_to_haiku_err(rc);
786	}
787
788
789	status_t vboxsf_write(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, const void buffer, size_t length)
790	{
791	vboxsf_volume* volume = _volume->private_volume;
792	vboxsf_vnode* vnode = _vnode->private_node;
793	vboxsf_file_cookie* cookie = _cookie;
794
795	if (*length > 0xFFFFFFFF)
796	*length = 0xFFFFFFFF;
797
798	uint32_t l = *length;
799	void* other_buffer = malloc(l); /** @todo map the user memory into kernel space here for efficiency */
800	memcpy(other_buffer, buffer, l);
801	int rc = VbglR0SfWrite(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false /fLocked/);
802	free(other_buffer);
803
804	*length = l;
805	return vbox_err_to_haiku_err(rc);
806	}
807
808
809	status_t vboxsf_write_stat(fs_volume volume, fs_vnode vnode, const struct stat *stat, uint32 statMask)
810	{
811	/* The host handles updating the stat info - in the guest, this is a no-op */
812	return B_OK;
813	}
814
815
816	status_t vboxsf_create_dir(fs_volume _volume, fs_vnode parent, const char *name, int perms)
817	{
818	vboxsf_volume* volume = _volume->private_volume;
819
820	SHFLCREATEPARMS params;
821	params.Handle = 0;
822	params.Info.cbObject = 0;
823	params.CreateFlags = SHFL_CF_DIRECTORY \| SHFL_CF_ACT_CREATE_IF_NEW \|
824	SHFL_CF_ACT_FAIL_IF_EXISTS \| SHFL_CF_ACCESS_READ;
825
826	PSHFLSTRING path = build_path(parent->private_node, name);
827	int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
828	free(path);
829	/** @todo r=ramshankar: we should perhaps also check rc here and change
830	* Handle initialization from 0 to SHFL_HANDLE_NIL. */
831	if (params.Handle == SHFL_HANDLE_NIL)
832	return vbox_err_to_haiku_err(rc);
833	VbglR0SfClose(&g_clientHandle, &volume->map, params.Handle);
834	return B_OK;
835	}
836
837
838	status_t vboxsf_remove_dir(fs_volume _volume, fs_vnode parent, const char *name)
839	{
840	vboxsf_volume* volume = _volume->private_volume;
841
842	PSHFLSTRING path = build_path(parent->private_node, name);
843	int rc = VbglR0SfRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_DIR);
844	free(path);
845
846	return vbox_err_to_haiku_err(rc);
847	}
848
849
850	status_t vboxsf_unlink(fs_volume _volume, fs_vnode parent, const char *name)
851	{
852	vboxsf_volume* volume = _volume->private_volume;
853
854	PSHFLSTRING path = build_path(parent->private_node, name);
855	int rc = VbglR0SfRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_FILE);
856	free(path);
857
858	return vbox_err_to_haiku_err(rc);
859	}
860
861	status_t vboxsf_link(fs_volume volume, fs_vnode dir, const char name, fs_vnode vnode)
862	{
863	return B_UNSUPPORTED;
864	}
865
866
867	status_t vboxsf_rename(fs_volume* _volume, fs_vnode* fromDir, const char* fromName, fs_vnode* toDir, const char* toName)
868	{
869	vboxsf_volume* volume = _volume->private_volume;
870
871	PSHFLSTRING oldpath = build_path(fromDir->private_node, fromName);
872	PSHFLSTRING newpath = build_path(toDir->private_node, toName);
873	int rc = VbglR0SfRename(&g_clientHandle, &volume->map, oldpath, newpath, SHFL_RENAME_FILE \| SHFL_RENAME_REPLACE_IF_EXISTS);
874	free(oldpath);
875	free(newpath);
876
877	return vbox_err_to_haiku_err(rc);
878	}
879
880
881	status_t vboxsf_create_symlink(fs_volume* _volume, fs_vnode* dir, const char* name, const char* path, int mode)
882	{
883	vboxsf_volume* volume = _volume->private_volume;
884
885	PSHFLSTRING target = make_shflstring(path);
886	PSHFLSTRING linkpath = build_path(dir->private_node, name);
887	SHFLFSOBJINFO stuff;
888	RT_ZERO(stuff);
889
890	int rc = VbglR0SfSymlink(&g_clientHandle, &volume->map, linkpath, target, &stuff);
891
892	free(target);
893	free(linkpath);
894
895	return vbox_err_to_haiku_err(rc);
896	}
897
898
899	status_t vboxsf_read_symlink(fs_volume* _volume, fs_vnode* link, char* buffer, size_t* _bufferSize)
900	{
901	vboxsf_volume* volume = _volume->private_volume;
902	vboxsf_vnode* vnode = link->private_node;
903
904	int rc = VbglR0SfReadLink(&g_clientHandle, &volume->map, vnode->path, *_bufferSize, buffer);
905	*_bufferSize = strlen(buffer);
906
907	return vbox_err_to_haiku_err(rc);
908	}
909
910
911	/** @todo move this into the runtime */
912	status_t vbox_err_to_haiku_err(int rc)
913	{
914	switch (rc)
915	{
916	case VINF_SUCCESS: return B_OK;
917	case VERR_INVALID_POINTER: return B_BAD_ADDRESS;
918	case VERR_INVALID_PARAMETER: return B_BAD_VALUE;
919	case VERR_PERMISSION_DENIED: return B_PERMISSION_DENIED;
920	case VERR_NOT_IMPLEMENTED: return B_UNSUPPORTED;
921	case VERR_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
922
923	case SHFL_PATH_NOT_FOUND:
924	case SHFL_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
925	case SHFL_FILE_EXISTS: return B_FILE_EXISTS;
926
927	default:
928	return B_ERROR;
929	}
930	}
931
932
933	static status_t std_ops(int32 op, ...)
934	{
935	switch(op)
936	{
937	case B_MODULE_INIT:
938	dprintf(MODULE_NAME ": B_MODULE_INIT\n");
939	return init_module();
940	case B_MODULE_UNINIT:
941	dprintf(MODULE_NAME ": B_MODULE_UNINIT\n");
942	uninit_module();
943	return B_OK;
944	default:
945	return B_ERROR;
946	}
947	}
948
949
950	static fs_volume_ops vboxsf_volume_ops =
951	{
952	unmount,
953	vboxsf_read_fs_info,
954	NULL, /* write_fs_info */
955	NULL, /* sync */
956	vboxsf_get_vnode,
957	NULL, /* open_index_dir */
958	NULL, /* close_index_dir */
959	NULL, /* free_index_dir_cookie */
960	NULL, /* read_index_dir */
961	NULL, /* rewind_index_dir */
962	NULL, /* create_index */
963	NULL, /* remove_index */
964	NULL, /* read_index_stat */
965	NULL, /* open_query */
966	NULL, /* close_query */
967	NULL, /* free_query_cookie */
968	NULL, /* read_query */
969	NULL, /* rewind_query */
970	NULL, /* all_layers_mounted */
971	NULL, /* create_sub_vnode */
972	NULL, /* delete_sub_vnode */
973	};
974
975	static fs_vnode_ops vboxsf_vnode_ops =
976	{
977	vboxsf_lookup,
978	NULL, /* get_vnode_name */
979	vboxsf_put_vnode,
980	NULL, /* remove_vnode */
981	NULL, /* can_page */
982	NULL, /* read_pages */
983	NULL, /* write_pages */
984	NULL, /* io */
985	NULL, /* cancel_io */
986	NULL, /* get_file_map */
987	NULL, /* ioctl */
988	NULL, /* set_flags */
989	NULL, /* select */
990	NULL, /* deselect */
991	NULL, /* fsync */
992	vboxsf_read_symlink,
993	vboxsf_create_symlink,
994	vboxsf_link,
995	vboxsf_unlink,
996	vboxsf_rename,
997	NULL, /* access */
998	vboxsf_read_stat,
999	vboxsf_write_stat,
1000	NULL, /* preallocate */
1001	vboxsf_create,
1002	vboxsf_open,
1003	vboxsf_close,
1004	vboxsf_free_cookie,
1005	vboxsf_read,
1006	vboxsf_write,
1007	vboxsf_create_dir,
1008	vboxsf_remove_dir,
1009	vboxsf_open_dir,
1010	vboxsf_close_dir,
1011	vboxsf_free_dir_cookie,
1012	vboxsf_read_dir,
1013	vboxsf_rewind_dir,
1014	NULL, /* open_attr_dir */
1015	NULL, /* close_attr_dir */
1016	NULL, /* free_attr_dir_cookie */
1017	NULL, /* read_attr_dir */
1018	NULL, /* rewind_attr_dir */
1019	NULL, /* create_attr */
1020	NULL, /* open_attr */
1021	NULL, /* close_attr */
1022	NULL, /* free_attr_cookie */
1023	NULL, /* read_attr */
1024	NULL, /* write_attr */
1025	NULL, /* read_attr_stat */
1026	NULL, /* write_attr_stat */
1027	NULL, /* rename_attr */
1028	NULL, /* remove_attr */
1029	NULL, /* create_special_node */
1030	NULL, /* get_super_vnode */
1031	};
1032
1033	static file_system_module_info sVBoxSharedFileSystem =
1034	{
1035	{
1036	MODULE_NAME B_CURRENT_FS_API_VERSION,
1037	0,
1038	std_ops,
1039	},
1040	FS_NAME,
1041	FS_PRETTY_NAME,
1042	0, /* DDM flags */
1043	NULL, /* identify_partition */
1044	NULL, /* scan_partition */
1045	NULL, /* free_identify_partition_cookie */
1046	NULL, /* free_partition_content_cookie */
1047	mount,
1048	};
1049
1050	module_info *modules[] =
1051	{
1052	(module_info *)&sVBoxSharedFileSystem,
1053	NULL,
1054	};
1055

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

source: vbox/trunk/src/VBox/Additions/haiku/SharedFolders/vboxsf.c@ 101702

Download in other formats: