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
18 static u32 vboxsf_client_id;
19
20 int 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
40 void 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
53 static 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
75 int 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
102 int 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 */
130 int 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
149 int 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
162 int 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
179 int 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
201 int 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
225 int 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 */
250 int 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
294 int 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
320 int 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
340 int 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
363 int vboxsf_set_utf8(void)
364 {
365 return vboxsf_call(SHFL_FN_SET_UTF8, NULL, 0, NULL);
366 }
367
368 int vboxsf_set_symlinks(void)
369 {
370 return vboxsf_call(SHFL_FN_SET_SYMLINKS, NULL, 0, NULL);
371 }
372
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.