1// SPDX-License-Identifier: MIT
2/*
3 * Wrapper functions for the shfl host calls.
4 *
5 * Copyright (C) 2006-2018 Oracle Corporation
6 */
7
8#include <linux/mm.h>
9#include <linux/slab.h>
10#include <linux/vbox_err.h>
11#include <linux/vbox_utils.h>
12#include "vfsmod.h"
13
14#define SHFL_REQUEST \
15	(VMMDEV_REQUESTOR_KERNEL | VMMDEV_REQUESTOR_USR_DRV_OTHER | \
16	 VMMDEV_REQUESTOR_CON_DONT_KNOW | VMMDEV_REQUESTOR_TRUST_NOT_GIVEN)
17
18static u32 vboxsf_client_id;
19
20int vboxsf_connect(void)
21{
22	struct vbg_dev *gdev;
23	struct vmmdev_hgcm_service_location loc;
24	int err, vbox_status;
25
26	loc.type = VMMDEV_HGCM_LOC_LOCALHOST_EXISTING;
27	strcpy(loc.u.localhost.service_name, "VBoxSharedFolders");
28
29	gdev = vbg_get_gdev();
30	if (IS_ERR(gdev))
31		return -ENODEV;	/* No guest-device */
32
33	err = vbg_hgcm_connect(gdev, SHFL_REQUEST, &loc,
34			       &vboxsf_client_id, &vbox_status);
35	vbg_put_gdev(gdev);
36
37	return err ? err : vbg_status_code_to_errno(vbox_status);
38}
39
40void vboxsf_disconnect(void)
41{
42	struct vbg_dev *gdev;
43	int vbox_status;
44
45	gdev = vbg_get_gdev();
46	if (IS_ERR(gdev))
47		return;   /* guest-device is gone, already disconnected */
48
49	vbg_hgcm_disconnect(gdev, SHFL_REQUEST, vboxsf_client_id, &vbox_status);
50	vbg_put_gdev(gdev);
51}
52
53static int vboxsf_call(u32 function, void *parms, u32 parm_count, int *status)
54{
55	struct vbg_dev *gdev;
56	int err, vbox_status;
57
58	gdev = vbg_get_gdev();
59	if (IS_ERR(gdev))
60		return -ESHUTDOWN; /* guest-dev removed underneath us */
61
62	err = vbg_hgcm_call(gdev, SHFL_REQUEST, vboxsf_client_id, function,
63			    U32_MAX, parms, parm_count, &vbox_status);
64	vbg_put_gdev(gdev);
65
66	if (err < 0)
67		return err;
68
69	if (status)
70		*status = vbox_status;
71
72	return vbg_status_code_to_errno(vbox_status);
73}
74
75int vboxsf_map_folder(struct shfl_string *folder_name, u32 *root)
76{
77	struct shfl_map_folder parms;
78	int err, status;
79
80	parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL;
81	parms.path.u.pointer.size = shfl_string_buf_size(folder_name);
82	parms.path.u.pointer.u.linear_addr = (uintptr_t)folder_name;
83
84	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
85	parms.root.u.value32 = 0;
86
87	parms.delimiter.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
88	parms.delimiter.u.value32 = '/';
89
90	parms.case_sensitive.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
91	parms.case_sensitive.u.value32 = 1;
92
93	err = vboxsf_call(SHFL_FN_MAP_FOLDER, &parms, SHFL_CPARMS_MAP_FOLDER,
94			  &status);
95	if (err == -ENOSYS && status == VERR_NOT_IMPLEMENTED)
96		vbg_err("%s: Error host is too old\n", __func__);
97
98	*root = parms.root.u.value32;
99	return err;
100}
101
102int vboxsf_unmap_folder(u32 root)
103{
104	struct shfl_unmap_folder parms;
105
106	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
107	parms.root.u.value32 = root;
108
109	return vboxsf_call(SHFL_FN_UNMAP_FOLDER, &parms,
110			   SHFL_CPARMS_UNMAP_FOLDER, NULL);
111}
112
113/**
114 * vboxsf_create - Create a new file or folder
115 * @root:         Root of the shared folder in which to create the file
116 * @parsed_path:  The path of the file or folder relative to the shared folder
117 * @create_parms: Parameters for file/folder creation.
118 *
119 * Create a new file or folder or open an existing one in a shared folder.
120 * Note this function always returns 0 / success unless an exceptional condition
121 * occurs - out of memory, invalid arguments, etc. If the file or folder could
122 * not be opened or created, create_parms->handle will be set to
123 * SHFL_HANDLE_NIL on return.  In this case the value in create_parms->result
124 * provides information as to why (e.g. SHFL_FILE_EXISTS), create_parms->result
125 * is also set on success as additional information.
126 *
127 * Returns:
128 * 0 or negative errno value.
129 */
130int vboxsf_create(u32 root, struct shfl_string *parsed_path,
131		  struct shfl_createparms *create_parms)
132{
133	struct shfl_create parms;
134
135	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
136	parms.root.u.value32 = root;
137
138	parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL;
139	parms.path.u.pointer.size = shfl_string_buf_size(parsed_path);
140	parms.path.u.pointer.u.linear_addr = (uintptr_t)parsed_path;
141
142	parms.parms.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL;
143	parms.parms.u.pointer.size = sizeof(struct shfl_createparms);
144	parms.parms.u.pointer.u.linear_addr = (uintptr_t)create_parms;
145
146	return vboxsf_call(SHFL_FN_CREATE, &parms, SHFL_CPARMS_CREATE, NULL);
147}
148
149int vboxsf_close(u32 root, u64 handle)
150{
151	struct shfl_close parms;
152
153	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
154	parms.root.u.value32 = root;
155
156	parms.handle.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
157	parms.handle.u.value64 = handle;
158
159	return vboxsf_call(SHFL_FN_CLOSE, &parms, SHFL_CPARMS_CLOSE, NULL);
160}
161
162int vboxsf_remove(u32 root, struct shfl_string *parsed_path, u32 flags)
163{
164	struct shfl_remove parms;
165
166	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
167	parms.root.u.value32 = root;
168
169	parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
170	parms.path.u.pointer.size = shfl_string_buf_size(parsed_path);
171	parms.path.u.pointer.u.linear_addr = (uintptr_t)parsed_path;
172
173	parms.flags.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
174	parms.flags.u.value32 = flags;
175
176	return vboxsf_call(SHFL_FN_REMOVE, &parms, SHFL_CPARMS_REMOVE, NULL);
177}
178
179int vboxsf_rename(u32 root, struct shfl_string *src_path,
180		  struct shfl_string *dest_path, u32 flags)
181{
182	struct shfl_rename parms;
183
184	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
185	parms.root.u.value32 = root;
186
187	parms.src.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
188	parms.src.u.pointer.size = shfl_string_buf_size(src_path);
189	parms.src.u.pointer.u.linear_addr = (uintptr_t)src_path;
190
191	parms.dest.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
192	parms.dest.u.pointer.size = shfl_string_buf_size(dest_path);
193	parms.dest.u.pointer.u.linear_addr = (uintptr_t)dest_path;
194
195	parms.flags.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
196	parms.flags.u.value32 = flags;
197
198	return vboxsf_call(SHFL_FN_RENAME, &parms, SHFL_CPARMS_RENAME, NULL);
199}
200
201int vboxsf_read(u32 root, u64 handle, u64 offset, u32 *buf_len, u8 *buf)
202{
203	struct shfl_read parms;
204	int err;
205
206	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
207	parms.root.u.value32 = root;
208
209	parms.handle.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
210	parms.handle.u.value64 = handle;
211	parms.offset.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
212	parms.offset.u.value64 = offset;
213	parms.cb.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
214	parms.cb.u.value32 = *buf_len;
215	parms.buffer.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT;
216	parms.buffer.u.pointer.size = *buf_len;
217	parms.buffer.u.pointer.u.linear_addr = (uintptr_t)buf;
218
219	err = vboxsf_call(SHFL_FN_READ, &parms, SHFL_CPARMS_READ, NULL);
220
221	*buf_len = parms.cb.u.value32;
222	return err;
223}
224
225int vboxsf_write(u32 root, u64 handle, u64 offset, u32 *buf_len, u8 *buf)
226{
227	struct shfl_write parms;
228	int err;
229
230	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
231	parms.root.u.value32 = root;
232
233	parms.handle.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
234	parms.handle.u.value64 = handle;
235	parms.offset.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
236	parms.offset.u.value64 = offset;
237	parms.cb.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
238	parms.cb.u.value32 = *buf_len;
239	parms.buffer.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
240	parms.buffer.u.pointer.size = *buf_len;
241	parms.buffer.u.pointer.u.linear_addr = (uintptr_t)buf;
242
243	err = vboxsf_call(SHFL_FN_WRITE, &parms, SHFL_CPARMS_WRITE, NULL);
244
245	*buf_len = parms.cb.u.value32;
246	return err;
247}
248
249/* Returns 0 on success, 1 on end-of-dir, negative errno otherwise */
250int vboxsf_dirinfo(u32 root, u64 handle,
251		   struct shfl_string *parsed_path, u32 flags, u32 index,
252		   u32 *buf_len, struct shfl_dirinfo *buf, u32 *file_count)
253{
254	struct shfl_list parms;
255	int err, status;
256
257	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
258	parms.root.u.value32 = root;
259
260	parms.handle.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
261	parms.handle.u.value64 = handle;
262	parms.flags.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
263	parms.flags.u.value32 = flags;
264	parms.cb.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
265	parms.cb.u.value32 = *buf_len;
266	if (parsed_path) {
267		parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
268		parms.path.u.pointer.size = shfl_string_buf_size(parsed_path);
269		parms.path.u.pointer.u.linear_addr = (uintptr_t)parsed_path;
270	} else {
271		parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_IN;
272		parms.path.u.pointer.size = 0;
273		parms.path.u.pointer.u.linear_addr = 0;
274	}
275
276	parms.buffer.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT;
277	parms.buffer.u.pointer.size = *buf_len;
278	parms.buffer.u.pointer.u.linear_addr = (uintptr_t)buf;
279
280	parms.resume_point.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
281	parms.resume_point.u.value32 = index;
282	parms.file_count.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
283	parms.file_count.u.value32 = 0;	/* out parameter only */
284
285	err = vboxsf_call(SHFL_FN_LIST, &parms, SHFL_CPARMS_LIST, &status);
286	if (err == -ENODATA && status == VERR_NO_MORE_FILES)
287		err = 1;
288
289	*buf_len = parms.cb.u.value32;
290	*file_count = parms.file_count.u.value32;
291	return err;
292}
293
294int vboxsf_fsinfo(u32 root, u64 handle, u32 flags,
295		  u32 *buf_len, void *buf)
296{
297	struct shfl_information parms;
298	int err;
299
300	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
301	parms.root.u.value32 = root;
302
303	parms.handle.type = VMMDEV_HGCM_PARM_TYPE_64BIT;
304	parms.handle.u.value64 = handle;
305	parms.flags.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
306	parms.flags.u.value32 = flags;
307	parms.cb.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
308	parms.cb.u.value32 = *buf_len;
309	parms.info.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL;
310	parms.info.u.pointer.size = *buf_len;
311	parms.info.u.pointer.u.linear_addr = (uintptr_t)buf;
312
313	err = vboxsf_call(SHFL_FN_INFORMATION, &parms, SHFL_CPARMS_INFORMATION,
314			  NULL);
315
316	*buf_len = parms.cb.u.value32;
317	return err;
318}
319
320int vboxsf_readlink(u32 root, struct shfl_string *parsed_path,
321		    u32 buf_len, u8 *buf)
322{
323	struct shfl_readLink parms;
324
325	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
326	parms.root.u.value32 = root;
327
328	parms.path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
329	parms.path.u.pointer.size = shfl_string_buf_size(parsed_path);
330	parms.path.u.pointer.u.linear_addr = (uintptr_t)parsed_path;
331
332	parms.buffer.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT;
333	parms.buffer.u.pointer.size = buf_len;
334	parms.buffer.u.pointer.u.linear_addr = (uintptr_t)buf;
335
336	return vboxsf_call(SHFL_FN_READLINK, &parms, SHFL_CPARMS_READLINK,
337			   NULL);
338}
339
340int vboxsf_symlink(u32 root, struct shfl_string *new_path,
341		   struct shfl_string *old_path, struct shfl_fsobjinfo *buf)
342{
343	struct shfl_symlink parms;
344
345	parms.root.type = VMMDEV_HGCM_PARM_TYPE_32BIT;
346	parms.root.u.value32 = root;
347
348	parms.new_path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
349	parms.new_path.u.pointer.size = shfl_string_buf_size(new_path);
350	parms.new_path.u.pointer.u.linear_addr = (uintptr_t)new_path;
351
352	parms.old_path.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN;
353	parms.old_path.u.pointer.size = shfl_string_buf_size(old_path);
354	parms.old_path.u.pointer.u.linear_addr = (uintptr_t)old_path;
355
356	parms.info.type = VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT;
357	parms.info.u.pointer.size = sizeof(struct shfl_fsobjinfo);
358	parms.info.u.pointer.u.linear_addr = (uintptr_t)buf;
359
360	return vboxsf_call(SHFL_FN_SYMLINK, &parms, SHFL_CPARMS_SYMLINK, NULL);
361}
362
363int vboxsf_set_utf8(void)
364{
365	return vboxsf_call(SHFL_FN_SET_UTF8, NULL, 0, NULL);
366}
367
368int vboxsf_set_symlinks(void)
369{
370	return vboxsf_call(SHFL_FN_SET_SYMLINKS, NULL, 0, NULL);
371}
372