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 * @param: 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