Changeset 30153 in vbox
- Timestamp:
- Jun 10, 2010 4:23:36 PM (15 years ago)
- svn:sync-xref-src-repo-rev:
- 62575
- Location:
- trunk/src/VBox/Additions/linux/sharedfolders
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Additions/linux/sharedfolders/dirops.c
r30150 r30153 20 20 21 21 static int 22 sf_dir_open 22 sf_dir_open(struct inode *inode, struct file *file) 23 23 { 24 24 int rc; 25 25 int err; 26 struct sf_glob_info *sf_g = GET_GLOB_INFO 26 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 27 27 struct sf_dir_info *sf_d; 28 struct sf_inode_info *sf_i = GET_INODE_INFO 28 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 29 29 SHFLCREATEPARMS params; 30 30 31 TRACE 32 BUG_ON 33 BUG_ON 31 TRACE(); 32 BUG_ON(!sf_g); 33 BUG_ON(!sf_i); 34 34 35 35 if (file->private_data) { … … 41 41 RT_ZERO(params); 42 42 43 sf_d = sf_dir_info_alloc 43 sf_d = sf_dir_info_alloc(); 44 44 45 45 if (!sf_d) { … … 58 58 LogFunc(("sf_dir_open: calling vboxCallCreate, folder %s, flags %#x\n", 59 59 sf_i->path->String.utf8, params.CreateFlags)); 60 rc = vboxCallCreate 61 if (RT_FAILURE 60 rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, ¶ms); 61 if (RT_FAILURE(rc)) { 62 62 LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n", 63 63 sf_i->path->String.utf8, rc)); 64 sf_dir_info_free 64 sf_dir_info_free(sf_d); 65 65 return -EPERM; 66 66 } … … 68 68 if (params.Result != SHFL_FILE_EXISTS) { 69 69 LogFunc(("directory %s does not exist\n", sf_i->path->String.utf8)); 70 sf_dir_info_free 70 sf_dir_info_free(sf_d); 71 71 return -ENOENT; 72 72 } 73 73 74 err = sf_dir_read_all 74 err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle); 75 75 if (err) { 76 rc = vboxCallClose 77 if (RT_FAILURE 76 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 77 if (RT_FAILURE(rc)) { 78 78 LogFunc(("vboxCallClose(%s) after err=%d failed rc=%Rrc\n", 79 79 sf_i->path->String.utf8, err, rc)); 80 80 } 81 sf_dir_info_free 81 sf_dir_info_free(sf_d); 82 82 return err; 83 83 } 84 84 85 85 86 rc = vboxCallClose 87 if (RT_FAILURE 86 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 87 if (RT_FAILURE(rc)) { 88 88 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", 89 89 sf_i->path->String.utf8, rc)); … … 98 98 directory and deallocate our own internal buffers */ 99 99 static int 100 sf_dir_release 101 { 102 struct sf_inode_info *sf_i = GET_INODE_INFO 103 104 TRACE 105 BUG_ON 100 sf_dir_release(struct inode *inode, struct file *file) 101 { 102 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 103 104 TRACE(); 105 BUG_ON(!sf_i); 106 106 107 107 if (file->private_data) { 108 sf_dir_info_free 108 sf_dir_info_free(file->private_data); 109 109 } 110 110 return 0; … … 117 117 -errno some form of error*/ 118 118 static int 119 sf_getdent 119 sf_getdent(struct file *dir, char d_name[NAME_MAX]) 120 120 { 121 121 loff_t cur; … … 126 126 struct list_head *pos, *list; 127 127 128 TRACE 129 130 sf_g = GET_GLOB_INFO 128 TRACE(); 129 130 sf_g = GET_GLOB_INFO(dir->f_dentry->d_inode->i_sb); 131 131 sf_d = dir->private_data; 132 132 133 BUG_ON 134 BUG_ON 133 BUG_ON(!sf_g); 134 BUG_ON(!sf_d); 135 135 136 136 inode = dir->f_dentry->d_inode; 137 137 sf_i = GET_INODE_INFO(inode); 138 138 139 BUG_ON 139 BUG_ON(!sf_i); 140 140 141 141 if (sf_i->force_reread) … … 156 156 LogFunc(("sf_getdent: calling vboxCallCreate, folder %s, flags %#x\n", 157 157 sf_i->path->String.utf8, params.CreateFlags)); 158 rc = vboxCallCreate 159 if (RT_FAILURE 158 rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, ¶ms); 159 if (RT_FAILURE(rc)) { 160 160 LogRel(("open failed %d\n", rc)); 161 161 LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n", … … 167 167 LogRel(("not exist %x\n", params.Result)); 168 168 LogFunc(("directory %s does not exist\n", sf_i->path->String.utf8)); 169 sf_dir_info_free 169 sf_dir_info_free(sf_d); 170 170 return -ENOENT; 171 171 } 172 172 173 sf_dir_info_empty 174 err = sf_dir_read_all 175 rc = vboxCallClose 176 if (RT_FAILURE 173 sf_dir_info_empty(sf_d); 174 err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle); 175 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 176 if (RT_FAILURE(rc)) { 177 177 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", 178 178 sf_i->path->String.utf8, rc)); … … 185 185 cur = 0; 186 186 list = &sf_d->info_list; 187 list_for_each 187 list_for_each(pos, list) { 188 188 struct sf_dir_buf *b; 189 189 SHFLDIRINFO *info; … … 192 192 char *name_ptr; 193 193 194 b = list_entry 194 b = list_entry(pos, struct sf_dir_buf, head); 195 195 if (dir->f_pos >= cur + b->nb_entries) { 196 196 cur += b->nb_entries; … … 201 201 size_t size; 202 202 203 size = offsetof 203 size = offsetof(SHFLDIRINFO, name.String) + info->name.u16Size; 204 204 info = (SHFLDIRINFO *) ((uintptr_t) info + size); 205 205 } … … 208 208 name_len = info->name.u16Length; 209 209 210 return sf_nlscpy 210 return sf_nlscpy(sf_g, d_name, NAME_MAX, name_ptr, name_len); 211 211 } 212 212 return 1; … … 237 237 sf_dir_read (struct file *dir, void *opaque, filldir_t filldir) 238 238 { 239 TRACE 239 TRACE(); 240 240 for (;;) { 241 241 int err; … … 244 244 char d_name[NAME_MAX]; 245 245 246 err = sf_getdent 246 err = sf_getdent(dir, d_name); 247 247 switch (err) { 248 248 case 1: … … 269 269 } 270 270 271 err = filldir (opaque, d_name, strlen(d_name),271 err = filldir(opaque, d_name, strlen(d_name), 272 272 dir->f_pos, fake_ino, DT_UNKNOWN); 273 273 if (err) { … … 281 281 } 282 282 283 BUG 283 BUG(); 284 284 } 285 285 … … 302 302 returned in case of succes and "negative" pointer on error */ 303 303 static struct dentry * 304 sf_lookup 305 #if LINUX_VERSION_CODE >= KERNEL_VERSION 304 sf_lookup(struct inode *parent, struct dentry *dentry 305 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 306 306 , struct nameidata *nd 307 307 #endif … … 316 316 RTFSOBJINFO fsinfo; 317 317 318 TRACE 319 sf_g = GET_GLOB_INFO 320 sf_i = GET_INODE_INFO 321 322 BUG_ON 323 BUG_ON 324 325 err = sf_path_from_dentry 318 TRACE(); 319 sf_g = GET_GLOB_INFO(parent->i_sb); 320 sf_i = GET_INODE_INFO(parent); 321 322 BUG_ON(!sf_g); 323 BUG_ON(!sf_i); 324 325 err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path); 326 326 if (err) { 327 327 goto fail0; 328 328 } 329 329 330 err = sf_stat 330 err = sf_stat(__func__, sf_g, path, &fsinfo, 1); 331 331 if (err) { 332 332 if (err == -ENOENT) { … … 338 338 } 339 339 else { 340 sf_new_i = kmalloc (sizeof(*sf_new_i), GFP_KERNEL);340 sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL); 341 341 if (!sf_new_i) { 342 342 LogRelFunc(("could not allocate memory for new inode info\n")); … … 346 346 sf_new_i->handle = SHFL_HANDLE_NIL; 347 347 348 ino = iunique 349 #if LINUX_VERSION_CODE >= KERNEL_VERSION 350 inode = iget_locked 348 ino = iunique(parent->i_sb, 1); 349 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 350 inode = iget_locked(parent->i_sb, ino); 351 351 #else 352 inode = iget 352 inode = iget(parent->i_sb, ino); 353 353 #endif 354 354 if (!inode) { … … 358 358 } 359 359 360 SET_INODE_INFO 361 sf_init_inode 360 SET_INODE_INFO(inode, sf_new_i); 361 sf_init_inode(sf_g, inode, &fsinfo); 362 362 sf_new_i->path = path; 363 363 364 #if LINUX_VERSION_CODE >= KERNEL_VERSION 364 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 365 365 unlock_new_inode(inode); 366 366 #endif … … 370 370 dentry->d_time = jiffies; 371 371 dentry->d_op = &sf_dentry_ops; 372 d_add 372 d_add(dentry, inode); 373 373 return NULL; 374 374 375 375 fail2: 376 kfree 376 kfree(sf_new_i); 377 377 fail1: 378 kfree 378 kfree(path); 379 379 fail0: 380 return ERR_PTR 380 return ERR_PTR(err); 381 381 } 382 382 … … 385 385 dentry */ 386 386 static int 387 sf_instantiate 387 sf_instantiate(const char *caller, struct inode *parent, 388 388 struct dentry *dentry, SHFLSTRING *path, 389 389 RTFSOBJINFO *info, SHFLHANDLE handle) … … 393 393 struct inode *inode; 394 394 struct sf_inode_info *sf_new_i; 395 struct sf_glob_info *sf_g = GET_GLOB_INFO 396 397 TRACE 398 BUG_ON 399 400 sf_new_i = kmalloc (sizeof(*sf_new_i), GFP_KERNEL);395 struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb); 396 397 TRACE(); 398 BUG_ON(!sf_g); 399 400 sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL); 401 401 if (!sf_new_i) { 402 402 LogRelFunc(("could not allocate inode info. caller=%s\n", caller)); … … 405 405 } 406 406 407 ino = iunique 408 #if LINUX_VERSION_CODE >= KERNEL_VERSION 409 inode = iget_locked 407 ino = iunique(parent->i_sb, 1); 408 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 409 inode = iget_locked(parent->i_sb, ino); 410 410 #else 411 inode = iget 411 inode = iget(parent->i_sb, ino); 412 412 #endif 413 413 if (!inode) { … … 417 417 } 418 418 419 sf_init_inode 419 sf_init_inode(sf_g, inode, info); 420 420 sf_new_i->path = path; 421 SET_INODE_INFO 421 SET_INODE_INFO(inode, sf_new_i); 422 422 423 423 dentry->d_time = jiffies; … … 425 425 sf_new_i->force_restat = 1; 426 426 427 d_instantiate 428 429 #if LINUX_VERSION_CODE >= KERNEL_VERSION 427 d_instantiate(dentry, inode); 428 429 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 430 430 unlock_new_inode(inode); 431 431 #endif … … 436 436 437 437 fail1: 438 kfree 438 kfree(sf_new_i); 439 439 fail0: 440 440 return err; … … 443 443 444 444 static int 445 sf_create_aux 445 sf_create_aux(struct inode *parent, struct dentry *dentry, int mode, int fDirectory) 446 446 { 447 447 int rc, err; 448 448 SHFLCREATEPARMS params; 449 449 SHFLSTRING *path; 450 struct sf_inode_info *sf_i = GET_INODE_INFO 451 struct sf_glob_info *sf_g = GET_GLOB_INFO 452 453 TRACE 454 BUG_ON 455 BUG_ON 450 struct sf_inode_info *sf_i = GET_INODE_INFO(parent); 451 struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb); 452 453 TRACE(); 454 BUG_ON(!sf_i); 455 BUG_ON(!sf_g); 456 456 457 457 #if 0 458 printk 458 printk("create_aux %s/%s\n", sf_i->path->String.utf8, 459 459 dentry->d_name.name); 460 460 #endif … … 466 466 467 467 params.CreateFlags = 0 468 | SHFL_CF_ACT_CREATE_IF_NEW469 | SHFL_CF_ACT_FAIL_IF_EXISTS470 | SHFL_CF_ACCESS_READWRITE471 | (fDirectory ? SHFL_CF_DIRECTORY : 0)472 ;468 | SHFL_CF_ACT_CREATE_IF_NEW 469 | SHFL_CF_ACT_FAIL_IF_EXISTS 470 | SHFL_CF_ACCESS_READWRITE 471 | (fDirectory ? SHFL_CF_DIRECTORY : 0) 472 ; 473 473 474 474 params.Info.Attr.fMode = 0 475 | (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE)476 | (mode & S_IRWXUGO)477 ;475 | (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE) 476 | (mode & S_IRWXUGO) 477 ; 478 478 479 479 params.Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING; 480 480 481 err = sf_path_from_dentry 481 err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path); 482 482 if (err) { 483 483 goto fail0; … … 486 486 LogFunc(("sf_create_aux: calling vboxCallCreate, folder %s, flags %#x\n", 487 487 path->String.utf8, params.CreateFlags)); 488 rc = vboxCallCreate 489 if (RT_FAILURE 488 rc = vboxCallCreate(&client_handle, &sf_g->map, path, ¶ms); 489 if (RT_FAILURE(rc)) { 490 490 if (rc == VERR_WRITE_PROTECT) { 491 491 err = -EROFS; … … 505 505 } 506 506 507 err = sf_instantiate 507 err = sf_instantiate(__func__, parent, dentry, path, ¶ms.Info, 508 508 fDirectory ? SHFL_HANDLE_NIL : params.Handle); 509 509 if (err) { … … 520 520 if (fDirectory) 521 521 { 522 rc = vboxCallClose 523 if (RT_FAILURE 522 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 523 if (RT_FAILURE(rc)) { 524 524 LogFunc(("(%d): vboxCallClose failed rc=%Rrc\n", fDirectory, rc)); 525 525 } … … 530 530 531 531 fail1: 532 rc = vboxCallClose 533 if (RT_FAILURE 532 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 533 if (RT_FAILURE(rc)) { 534 534 LogFunc(("(%d): vboxCallClose failed rc=%Rrc\n", fDirectory, rc)); 535 535 } 536 536 537 537 fail0: 538 kfree 538 kfree(path); 539 539 return err; 540 540 } 541 541 542 542 static int 543 sf_create 544 #if LINUX_VERSION_CODE >= KERNEL_VERSION 543 sf_create(struct inode *parent, struct dentry *dentry, int mode 544 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 545 545 , struct nameidata *nd 546 546 #endif 547 547 ) 548 548 { 549 TRACE 550 return sf_create_aux 551 } 552 553 static int 554 sf_mkdir 555 { 556 TRACE 557 return sf_create_aux 558 } 559 560 static int 561 sf_unlink_aux 549 TRACE(); 550 return sf_create_aux(parent, dentry, mode, 0); 551 } 552 553 static int 554 sf_mkdir(struct inode *parent, struct dentry *dentry, int mode) 555 { 556 TRACE(); 557 return sf_create_aux(parent, dentry, mode, 1); 558 } 559 560 static int 561 sf_unlink_aux(struct inode *parent, struct dentry *dentry, int fDirectory) 562 562 { 563 563 int rc, err; 564 struct sf_glob_info *sf_g = GET_GLOB_INFO 565 struct sf_inode_info *sf_i = GET_INODE_INFO 564 struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb); 565 struct sf_inode_info *sf_i = GET_INODE_INFO(parent); 566 566 SHFLSTRING *path; 567 567 568 TRACE 569 BUG_ON 570 571 err = sf_path_from_dentry 568 TRACE(); 569 BUG_ON(!sf_g); 570 571 err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path); 572 572 if (err) { 573 573 goto fail0; 574 574 } 575 575 576 rc = vboxCallRemove 576 rc = vboxCallRemove(&client_handle, &sf_g->map, path, 577 577 fDirectory ? SHFL_REMOVE_DIR : SHFL_REMOVE_FILE); 578 if (RT_FAILURE 578 if (RT_FAILURE(rc)) { 579 579 LogFunc(("(%d): vboxCallRemove(%s) failed rc=%Rrc\n", fDirectory, 580 580 path->String.utf8, rc)); 581 err = -RTErrConvertToErrno 581 err = -RTErrConvertToErrno(rc); 582 582 goto fail1; 583 583 } … … 587 587 /* directory content changed */ 588 588 sf_i->force_reread = 1; 589 kfree 589 kfree(path); 590 590 return 0; 591 591 592 592 fail1: 593 kfree 593 kfree(path); 594 594 fail0: 595 595 return err; … … 597 597 598 598 static int 599 sf_unlink 600 { 601 TRACE 602 return sf_unlink_aux 603 } 604 605 static int 606 sf_rmdir 607 { 608 TRACE 609 return sf_unlink_aux 610 } 611 612 static int 613 sf_rename 599 sf_unlink(struct inode *parent, struct dentry *dentry) 600 { 601 TRACE(); 602 return sf_unlink_aux(parent, dentry, 0); 603 } 604 605 static int 606 sf_rmdir(struct inode *parent, struct dentry *dentry) 607 { 608 TRACE(); 609 return sf_unlink_aux(parent, dentry, 1); 610 } 611 612 static int 613 sf_rename(struct inode *old_parent, struct dentry *old_dentry, 614 614 struct inode *new_parent, struct dentry *new_dentry) 615 615 { 616 616 int err = 0, rc = VINF_SUCCESS; 617 struct sf_glob_info *sf_g = GET_GLOB_INFO 618 619 TRACE 620 621 if (sf_g != GET_GLOB_INFO 617 struct sf_glob_info *sf_g = GET_GLOB_INFO(old_parent->i_sb); 618 619 TRACE(); 620 621 if (sf_g != GET_GLOB_INFO(new_parent->i_sb)) { 622 622 LogFunc(("rename with different roots\n")); 623 623 err = -EINVAL; 624 624 } else { 625 struct sf_inode_info *sf_old_i = GET_INODE_INFO 626 struct sf_inode_info *sf_new_i = GET_INODE_INFO 625 struct sf_inode_info *sf_old_i = GET_INODE_INFO(old_parent); 626 struct sf_inode_info *sf_new_i = GET_INODE_INFO(new_parent); 627 627 /* As we save the relative path inside the inode structure, we need to change 628 628 this if the rename is successful. */ 629 struct sf_inode_info *sf_file_i = GET_INODE_INFO 629 struct sf_inode_info *sf_file_i = GET_INODE_INFO(old_dentry->d_inode); 630 630 SHFLSTRING *old_path; 631 631 SHFLSTRING *new_path; 632 632 633 BUG_ON 634 BUG_ON 635 BUG_ON 633 BUG_ON(!sf_old_i); 634 BUG_ON(!sf_new_i); 635 BUG_ON(!sf_file_i); 636 636 637 637 old_path = sf_file_i->path; 638 err = sf_path_from_dentry 638 err = sf_path_from_dentry(__func__, sf_g, sf_new_i, 639 639 new_dentry, &new_path); 640 640 if (err) { … … 643 643 int is_dir = ((old_dentry->d_inode->i_mode & S_IFDIR) != 0); 644 644 645 rc = vboxCallRename 645 rc = vboxCallRename(&client_handle, &sf_g->map, old_path, 646 646 new_path, is_dir ? 0 : SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS); 647 647 if (RT_SUCCESS(rc)) { 648 kfree 648 kfree(old_path); 649 649 sf_new_i->force_restat = 1; 650 650 sf_old_i->force_restat = 1; /* XXX: needed? */ … … 653 653 } else { 654 654 LogFunc(("vboxCallRename failed rc=%Rrc\n", rc)); 655 err = -RTErrConvertToErrno 655 err = -RTErrConvertToErrno(rc); 656 656 } 657 657 if (0 != err) 658 kfree 658 kfree(new_path); 659 659 } 660 660 } … … 669 669 .unlink = sf_unlink, 670 670 .rename = sf_rename, 671 #if LINUX_VERSION_CODE < KERNEL_VERSION 671 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 672 672 .revalidate = sf_inode_revalidate 673 673 #else -
trunk/src/VBox/Additions/linux/sharedfolders/mount.vboxsf.c
r28998 r30153 74 74 75 75 static void PANIC_ATTR 76 panic 76 panic(const char *fmt, ...) 77 77 { 78 78 va_list ap; 79 79 80 va_start 81 vfprintf 82 va_end 83 exit 80 va_start(ap, fmt); 81 vfprintf(stderr, fmt, ap); 82 va_end(ap); 83 exit(EXIT_FAILURE); 84 84 } 85 85 86 86 static void PANIC_ATTR 87 panic_err 87 panic_err(const char *fmt, ...) 88 88 { 89 89 va_list ap; 90 90 int errno_code = errno; 91 91 92 va_start 93 vfprintf 94 va_end 95 fprintf (stderr, ": %s\n", strerror(errno_code));96 exit 92 va_start(ap, fmt); 93 vfprintf(stderr, fmt, ap); 94 va_end(ap); 95 fprintf(stderr, ": %s\n", strerror(errno_code)); 96 exit(EXIT_FAILURE); 97 97 } 98 98 99 99 static int 100 safe_atoi 100 safe_atoi(const char *s, size_t size, int base) 101 101 { 102 102 char *endptr; 103 long long int val = strtoll 103 long long int val = strtoll(s, &endptr, base); 104 104 105 105 if (val < INT_MIN || val > INT_MAX || endptr < s + size) 106 106 { 107 107 errno = ERANGE; 108 panic_err 108 panic_err("could not convert %.*s to integer, result = %d", 109 109 (int)size, s, (int) val); 110 110 } 111 return (int) 111 return (int)val; 112 112 } 113 113 114 114 static void 115 process_mount_opts 115 process_mount_opts(const char *s, struct opts *opts) 116 116 { 117 117 const char *next = s; … … 180 180 181 181 s = next; 182 next = strchr 182 next = strchr(s, ','); 183 183 if (!next) 184 184 { 185 len = strlen 185 len = strlen(s); 186 186 } 187 187 else … … 220 220 if (!(val && *val)) 221 221 { 222 panic 222 panic("%.*s requires an argument (i.e. %.*s=<arg>)\n", 223 223 (int)len, s, (int)len, s); 224 224 } … … 256 256 case HOUID: 257 257 /** @todo convert string to id. */ 258 opts->uid = safe_atoi 258 opts->uid = safe_atoi(val, val_len, 10); 259 259 break; 260 260 case HOGID: 261 261 /** @todo convert string to id. */ 262 opts->gid = safe_atoi 262 opts->gid = safe_atoi(val, val_len, 10); 263 263 break; 264 264 case HOTTL: 265 opts->ttl = safe_atoi 265 opts->ttl = safe_atoi(val, val_len, 10); 266 266 break; 267 267 case HODMODE: 268 opts->dmode = safe_atoi 268 opts->dmode = safe_atoi(val, val_len, 8); 269 269 break; 270 270 case HOFMODE: 271 opts->fmode = safe_atoi 271 opts->fmode = safe_atoi(val, val_len, 8); 272 272 break; 273 273 case HOUMASK: 274 opts->dmask = opts->fmask = safe_atoi 274 opts->dmask = opts->fmask = safe_atoi(val, val_len, 8); 275 275 break; 276 276 case HODMASK: 277 opts->dmask = safe_atoi 277 opts->dmask = safe_atoi(val, val_len, 8); 278 278 break; 279 279 case HOFMASK: 280 opts->fmask = safe_atoi 280 opts->fmask = safe_atoi(val, val_len, 8); 281 281 break; 282 282 case HOIOCHARSET: 283 if (val_len + 1 > sizeof 283 if (val_len + 1 > sizeof(opts->nls_name)) 284 284 { 285 panic 285 panic("iocharset name too long\n"); 286 286 } 287 memcpy 287 memcpy(opts->nls_name, val, val_len); 288 288 opts->nls_name[val_len] = 0; 289 289 break; 290 290 case HOCONVERTCP: 291 opts->convertcp = malloc 291 opts->convertcp = malloc(val_len + 1); 292 292 if (!opts->convertcp) 293 293 { 294 panic_err 294 panic_err("could not allocate memory"); 295 295 } 296 memcpy 296 memcpy(opts->convertcp, val, val_len); 297 297 opts->convertcp[val_len] = 0; 298 298 break; … … 308 308 if (!handler->name) 309 309 { 310 fprintf 311 fprintf 310 fprintf(stderr, "unknown mount option `%.*s'\n", (int)len, s); 311 fprintf(stderr, "valid options:\n"); 312 312 313 313 for (handler = handlers; handler->name; ++handler) 314 314 { 315 315 if (handler->desc) 316 fprintf 316 fprintf(stderr, " %-10s%s %s\n", handler->name, 317 317 handler->has_arg ? "=<arg>" : "", handler->desc); 318 318 } 319 exit 319 exit(EXIT_FAILURE); 320 320 } 321 321 } … … 323 323 324 324 static void 325 complete 325 complete(char *host_name, char *mount_point, 326 326 unsigned long flags, struct opts *opts) 327 327 { … … 331 331 struct mntent e; 332 332 333 m = open_memstream 333 m = open_memstream(&buf, &size); 334 334 if (!m) 335 panic_err 335 panic_err("could not update mount table (failed to create memstream)"); 336 336 337 337 if (opts->uid) 338 fprintf 338 fprintf(m, "uid=%d,", opts->uid); 339 339 if (opts->gid) 340 fprintf 340 fprintf(m, "gid=%d,", opts->gid); 341 341 if (opts->ttl) 342 fprintf 342 fprintf(m, "ttl=%d,", opts->ttl); 343 343 if (*opts->nls_name) 344 fprintf 344 fprintf(m, "iocharset=%s,", opts->nls_name); 345 345 if (flags & MS_NOSUID) 346 fprintf 346 fprintf(m, "%s,", MNTOPT_NOSUID); 347 347 if (flags & MS_RDONLY) 348 fprintf 348 fprintf(m, "%s,", MNTOPT_RO); 349 349 else 350 fprintf 351 352 fclose 350 fprintf(m, "%s,", MNTOPT_RW); 351 352 fclose(m); 353 353 354 354 if (size > 0) … … 357 357 buf = "defaults"; 358 358 359 f = setmntent 359 f = setmntent(MOUNTED, "a+"); 360 360 if (!f) 361 panic_err 361 panic_err("could not open mount table for update"); 362 362 363 363 e.mnt_fsname = host_name; … … 368 368 e.mnt_passno = 0; 369 369 370 if (addmntent 370 if (addmntent(f, &e)) 371 371 { 372 372 if (size > 0) 373 373 { 374 memset 375 free 376 } 377 panic_err 378 } 379 380 endmntent 374 memset(buf, 0, size); 375 free(buf); 376 } 377 panic_err("could not add an entry to the mount table"); 378 } 379 380 endmntent(f); 381 381 382 382 if (size > 0) 383 383 { 384 memset 385 free 384 memset(buf, 0, size); 385 free(buf); 386 386 } 387 387 } 388 388 389 389 static void 390 convertcp 390 convertcp(char *in_codeset, char *host_name, struct vbsf_mount_info_new *info) 391 391 { 392 392 char *i = host_name; 393 393 char *o = info->name; 394 size_t ib = strlen 395 size_t ob = sizeof 394 size_t ib = strlen(host_name); 395 size_t ob = sizeof(info->name) - 1; 396 396 iconv_t cd; 397 397 398 cd = iconv_open 398 cd = iconv_open("UTF-8", in_codeset); 399 399 if (cd == (iconv_t) -1) 400 400 { 401 panic_err 401 panic_err("could not convert share name, iconv_open `%s' failed", 402 402 in_codeset); 403 403 } … … 405 405 while (ib) 406 406 { 407 size_t c = iconv 407 size_t c = iconv(cd, &i, &ib, &o, &ob); 408 408 if (c == (size_t) -1) 409 409 { 410 panic_err 411 410 panic_err("could not convert share name(%s) at %d", 411 host_name, (int)(strlen (host_name) - ib)); 412 412 } 413 413 } … … 485 485 mntinf.length = sizeof(mntinf); 486 486 487 if (getuid 488 panic 487 if (getuid()) 488 panic("Only root can mount shared folders from the host.\n"); 489 489 490 490 if (!argv[0]) … … 495 495 CT_ASSERT(sizeof(gid_t) == sizeof(int)); 496 496 497 while ((c = getopt 497 while ((c = getopt(argc, argv, "rwno:h")) != -1) 498 498 { 499 499 switch (c) 500 500 { 501 501 default: 502 fprintf 502 fprintf(stderr, "unknown option `%c:%#x'\n", c, c); 503 503 case '?': 504 504 case 'h': … … 513 513 514 514 case 'o': 515 process_mount_opts 515 process_mount_opts(optarg, &opts); 516 516 break; 517 517 … … 529 529 530 530 if (opts.convertcp) 531 convertcp 531 convertcp(opts.convertcp, host_name, &mntinf); 532 532 else 533 533 { 534 if (strlen 535 panic 536 537 strcpy 538 } 539 540 if (strlen 541 panic 542 543 strcpy 534 if (strlen(host_name) > MAX_HOST_NAME - 1) 535 panic("host name is too big\n"); 536 537 strcpy(mntinf.name, host_name); 538 } 539 540 if (strlen(opts.nls_name) > MAX_NLS_NAME - 1) 541 panic("%s: the character set name for I/O is too long.\n", argv[0]); 542 543 strcpy(mntinf.nls_name, opts.nls_name); 544 544 545 545 if (opts.ronly) … … 558 558 mntinf.fmask = opts.fmask; 559 559 560 err = mount 560 err = mount(NULL, mount_point, "vboxsf", flags, &mntinf); 561 561 if (err == -1 && errno == EPROTO) 562 562 { … … 573 573 ++cchCWD; 574 574 /* We checked before that we have enough space */ 575 strcpy 576 } 577 err = mount 575 strcpy(mntinf.name, host_name + cchCWD); 576 } 577 err = mount(NULL, mount_point, "vboxsf", flags, &mntinf); 578 578 } 579 579 if (err == -1 && errno == EPROTO) … … 587 587 mntinf_old.gid = mntinf.gid; 588 588 mntinf_old.ttl = mntinf.ttl; 589 err = mount 589 err = mount(NULL, mount_point, "vboxsf", flags, &mntinf_old); 590 590 } 591 591 if (err) 592 panic_err 592 panic_err("%s: mounting failed with the error", argv[0]); 593 593 594 594 if (!nomtab) 595 complete 596 597 exit 598 } 595 complete(host_name, mount_point, flags, &opts); 596 597 exit(EXIT_SUCCESS); 598 } -
trunk/src/VBox/Additions/linux/sharedfolders/regops.c
r29935 r30153 24 24 25 25 26 static void *alloc_bounch_buffer 26 static void *alloc_bounch_buffer(size_t *tmp_sizep, PRTCCPHYS physp, size_t xfer_size, const char *caller) 27 27 { 28 28 size_t tmp_size; … … 33 33 if (tmp_size > 16U*_1K) 34 34 tmp_size = 16U*_1K; 35 tmp = kmalloc 35 tmp = kmalloc(tmp_size, GFP_KERNEL); 36 36 if (!tmp) { 37 37 38 38 /* fall back on a page sized buffer. */ 39 tmp = kmalloc 39 tmp = kmalloc(PAGE_SIZE, GFP_KERNEL); 40 40 if (!tmp) { 41 41 LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size)); … … 50 50 } 51 51 52 static void free_bounch_buffer 52 static void free_bounch_buffer(void *tmp) 53 53 { 54 54 kfree (tmp); … … 58 58 /* fops */ 59 59 static int 60 sf_reg_read_aux 61 62 60 sf_reg_read_aux(const char *caller, struct sf_glob_info *sf_g, 61 struct sf_reg_info *sf_r, void *buf, uint32_t *nread, 62 uint64_t pos) 63 63 { 64 64 /** @todo bird: yes, kmap() and kmalloc() input only. Since the buffer is 65 65 * contiguous in physical memory (kmalloc or single page), we should 66 66 * use a physical address here to speed things up. */ 67 int rc = vboxCallRead 68 69 if (RT_FAILURE 67 int rc = vboxCallRead(&client_handle, &sf_g->map, sf_r->handle, 68 pos, nread, buf, false /* already locked? */); 69 if (RT_FAILURE(rc)) { 70 70 LogFunc(("vboxCallRead failed. caller=%s, rc=%Rrc\n", 71 71 caller, rc)); … … 76 76 77 77 static int 78 sf_reg_write_aux 78 sf_reg_write_aux(const char *caller, struct sf_glob_info *sf_g, 79 79 struct sf_reg_info *sf_r, void *buf, uint32_t *nwritten, 80 80 uint64_t pos) … … 83 83 * contiguous in physical memory (kmalloc or single page), we should 84 84 * use a physical address here to speed things up. */ 85 int rc = vboxCallWrite 85 int rc = vboxCallWrite(&client_handle, &sf_g->map, sf_r->handle, 86 86 pos, nwritten, buf, false /* already locked? */); 87 if (RT_FAILURE 87 if (RT_FAILURE(rc)) { 88 88 LogFunc(("vboxCallWrite failed. caller=%s, rc=%Rrc\n", 89 89 caller, rc)); … … 94 94 95 95 static ssize_t 96 sf_reg_read 96 sf_reg_read(struct file *file, char *buf, size_t size, loff_t *off) 97 97 { 98 98 int err; … … 103 103 ssize_t total_bytes_read = 0; 104 104 struct inode *inode = file->f_dentry->d_inode; 105 struct sf_glob_info *sf_g = GET_GLOB_INFO 105 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 106 106 struct sf_reg_info *sf_r = file->private_data; 107 107 loff_t pos = *off; 108 108 109 TRACE 110 if (!S_ISREG 109 TRACE(); 110 if (!S_ISREG(inode->i_mode)) { 111 111 LogFunc(("read from non regular file %d\n", inode->i_mode)); 112 112 return -EINVAL; … … 119 119 } 120 120 121 tmp = alloc_bounch_buffer 121 tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__); 122 122 if (!tmp) 123 123 return -ENOMEM; … … 132 132 nread = to_read; 133 133 134 err = sf_reg_read_aux 134 err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos); 135 135 if (err) 136 136 goto fail; 137 137 138 if (copy_to_user 138 if (copy_to_user(buf, tmp, nread)) { 139 139 err = -EFAULT; 140 140 goto fail; … … 151 151 152 152 *off += total_bytes_read; 153 free_bounch_buffer 153 free_bounch_buffer(tmp); 154 154 return total_bytes_read; 155 155 156 156 fail: 157 free_bounch_buffer 157 free_bounch_buffer(tmp); 158 158 return err; 159 159 } 160 160 161 161 static ssize_t 162 sf_reg_write 162 sf_reg_write(struct file *file, const char *buf, size_t size, loff_t *off) 163 163 { 164 164 int err; … … 169 169 ssize_t total_bytes_written = 0; 170 170 struct inode *inode = file->f_dentry->d_inode; 171 struct sf_inode_info *sf_i = GET_INODE_INFO 172 struct sf_glob_info *sf_g = GET_GLOB_INFO 171 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 172 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 173 173 struct sf_reg_info *sf_r = file->private_data; 174 174 loff_t pos; 175 175 176 TRACE 177 BUG_ON 178 BUG_ON 179 BUG_ON 180 181 if (!S_ISREG 176 TRACE(); 177 BUG_ON(!sf_i); 178 BUG_ON(!sf_g); 179 BUG_ON(!sf_r); 180 181 if (!S_ISREG(inode->i_mode)) { 182 182 LogFunc(("write to non regular file %d\n", inode->i_mode)); 183 183 return -EINVAL; … … 196 196 return 0; 197 197 198 tmp = alloc_bounch_buffer 198 tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__); 199 199 if (!tmp) 200 200 return -ENOMEM; … … 209 209 nwritten = to_write; 210 210 211 if (copy_from_user 211 if (copy_from_user(tmp, buf, to_write)) { 212 212 err = -EFAULT; 213 213 goto fail; … … 216 216 #if 1 217 217 if (VbglR0CanUsePhysPageList()) { 218 err = VbglR0SfWritePhysCont 219 218 err = VbglR0SfWritePhysCont(&client_handle, &sf_g->map, sf_r->handle, 219 pos, &nwritten, tmp_phys); 220 220 err = RT_FAILURE(err) ? -EPROTO : 0; 221 221 } else 222 222 #endif 223 err = sf_reg_write_aux 223 err = sf_reg_write_aux(__func__, sf_g, sf_r, tmp, &nwritten, pos); 224 224 if (err) 225 225 goto fail; … … 238 238 239 239 sf_i->force_restat = 1; 240 free_bounch_buffer 240 free_bounch_buffer(tmp); 241 241 return total_bytes_written; 242 242 243 243 fail: 244 free_bounch_buffer 244 free_bounch_buffer(tmp); 245 245 return err; 246 246 } 247 247 248 248 static int 249 sf_reg_open 249 sf_reg_open(struct inode *inode, struct file *file) 250 250 { 251 251 int rc, rc_linux = 0; 252 struct sf_glob_info *sf_g = GET_GLOB_INFO 253 struct sf_inode_info *sf_i = GET_INODE_INFO 252 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 253 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 254 254 struct sf_reg_info *sf_r; 255 255 SHFLCREATEPARMS params; 256 256 257 TRACE 258 BUG_ON 259 BUG_ON 257 TRACE(); 258 BUG_ON(!sf_g); 259 BUG_ON(!sf_i); 260 260 261 261 LogFunc(("open %s\n", sf_i->path->String.utf8)); 262 262 263 sf_r = kmalloc (sizeof(*sf_r), GFP_KERNEL);263 sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL); 264 264 if (!sf_r) { 265 265 LogRelFunc(("could not allocate reg info\n")); … … 342 342 LogFunc(("sf_reg_open: calling vboxCallCreate, file %s, flags=%#x, %#x\n", 343 343 sf_i->path->String.utf8 , file->f_flags, params.CreateFlags)); 344 rc = vboxCallCreate 345 346 if (RT_FAILURE 344 rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, ¶ms); 345 346 if (RT_FAILURE(rc)) { 347 347 LogFunc(("vboxCallCreate failed flags=%d,%#x rc=%Rrc\n", 348 348 file->f_flags, params.CreateFlags, rc)); 349 kfree 349 kfree(sf_r); 350 350 return -RTErrConvertToErrno(rc); 351 351 } … … 373 373 374 374 static int 375 sf_reg_release 375 sf_reg_release(struct inode *inode, struct file *file) 376 376 { 377 377 int rc; 378 378 struct sf_reg_info *sf_r; 379 379 struct sf_glob_info *sf_g; 380 struct sf_inode_info *sf_i = GET_INODE_INFO 381 382 TRACE 383 sf_g = GET_GLOB_INFO 380 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 381 382 TRACE(); 383 sf_g = GET_GLOB_INFO(inode->i_sb); 384 384 sf_r = file->private_data; 385 385 386 BUG_ON 387 BUG_ON 388 389 rc = vboxCallClose 390 if (RT_FAILURE 386 BUG_ON(!sf_g); 387 BUG_ON(!sf_r); 388 389 rc = vboxCallClose(&client_handle, &sf_g->map, sf_r->handle); 390 if (RT_FAILURE(rc)) { 391 391 LogFunc(("vboxCallClose failed rc=%Rrc\n", rc)); 392 392 } 393 393 394 kfree 394 kfree(sf_r); 395 395 sf_i->file = NULL; 396 396 sf_i->handle = SHFL_HANDLE_NIL; … … 399 399 } 400 400 401 #if LINUX_VERSION_CODE > KERNEL_VERSION 401 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 402 402 static int 403 403 sf_reg_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 404 #elif LINUX_VERSION_CODE >= KERNEL_VERSION 404 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 405 405 static struct page * 406 sf_reg_nopage 406 sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int *type) 407 407 # define SET_TYPE(t) *type = (t) 408 408 #else /* LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0) */ 409 409 static struct page * 410 sf_reg_nopage 410 sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int unused) 411 411 # define SET_TYPE(t) 412 412 #endif … … 419 419 struct file *file = vma->vm_file; 420 420 struct inode *inode = file->f_dentry->d_inode; 421 struct sf_glob_info *sf_g = GET_GLOB_INFO 421 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 422 422 struct sf_reg_info *sf_r = file->private_data; 423 423 424 TRACE 425 #if LINUX_VERSION_CODE > KERNEL_VERSION 424 TRACE(); 425 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 426 426 if (vmf->pgoff > vma->vm_end) 427 427 return VM_FAULT_SIGBUS; 428 428 #else 429 429 if (vaddr > vma->vm_end) { 430 SET_TYPE 430 SET_TYPE(VM_FAULT_SIGBUS); 431 431 return NOPAGE_SIGBUS; 432 432 } 433 433 #endif 434 434 435 page = alloc_page 435 page = alloc_page(GFP_HIGHUSER); 436 436 if (!page) { 437 437 LogRelFunc(("failed to allocate page\n")); 438 #if LINUX_VERSION_CODE > KERNEL_VERSION 438 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 439 439 return VM_FAULT_OOM; 440 440 #else 441 SET_TYPE 441 SET_TYPE(VM_FAULT_OOM); 442 442 return NOPAGE_OOM; 443 443 #endif 444 444 } 445 445 446 buf = kmap 447 #if LINUX_VERSION_CODE > KERNEL_VERSION 446 buf = kmap(page); 447 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 448 448 off = (vmf->pgoff << PAGE_SHIFT); 449 449 #else 450 450 off = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT); 451 451 #endif 452 err = sf_reg_read_aux 452 err = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off); 453 453 if (err) { 454 kunmap 455 put_page 456 #if LINUX_VERSION_CODE > KERNEL_VERSION 454 kunmap(page); 455 put_page(page); 456 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 457 457 return VM_FAULT_SIGBUS; 458 458 #else 459 SET_TYPE 459 SET_TYPE(VM_FAULT_SIGBUS); 460 460 return NOPAGE_SIGBUS; 461 461 #endif … … 464 464 BUG_ON (nread > PAGE_SIZE); 465 465 if (!nread) { 466 #if LINUX_VERSION_CODE > KERNEL_VERSION 467 clear_user_page (page_address(page), vmf->pgoff, page);468 #elif LINUX_VERSION_CODE >= KERNEL_VERSION 469 clear_user_page (page_address(page), vaddr, page);470 #else 471 clear_user_page (page_address(page), vaddr);466 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 467 clear_user_page(page_address(page), vmf->pgoff, page); 468 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 469 clear_user_page(page_address(page), vaddr, page); 470 #else 471 clear_user_page(page_address(page), vaddr); 472 472 #endif 473 473 } 474 474 else { 475 memset 476 } 477 478 flush_dcache_page 479 kunmap 480 #if LINUX_VERSION_CODE > KERNEL_VERSION 475 memset(buf + nread, 0, PAGE_SIZE - nread); 476 } 477 478 flush_dcache_page(page); 479 kunmap(page); 480 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 481 481 vmf->page = page; 482 482 return 0; 483 483 #else 484 SET_TYPE 484 SET_TYPE(VM_FAULT_MAJOR); 485 485 return page; 486 486 #endif … … 488 488 489 489 static struct vm_operations_struct sf_vma_ops = { 490 #if LINUX_VERSION_CODE > KERNEL_VERSION 490 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25) 491 491 .fault = sf_reg_fault 492 492 #else … … 496 496 497 497 static int 498 sf_reg_mmap 499 { 500 TRACE 498 sf_reg_mmap(struct file *file, struct vm_area_struct *vma) 499 { 500 TRACE(); 501 501 if (vma->vm_flags & VM_SHARED) { 502 502 LogFunc(("shared mmapping not available\n")); … … 514 514 .release = sf_reg_release, 515 515 .mmap = sf_reg_mmap, 516 #if LINUX_VERSION_CODE >= KERNEL_VERSION 517 # if LINUX_VERSION_CODE >= KERNEL_VERSION 516 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 517 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23) 518 518 .splice_read = generic_file_splice_read, 519 519 # else … … 522 522 .aio_read = generic_file_aio_read, 523 523 .aio_write = generic_file_aio_write, 524 # if LINUX_VERSION_CODE >= KERNEL_VERSION 524 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35) 525 525 .fsync = noop_fsync, 526 526 # else … … 533 533 534 534 struct inode_operations sf_reg_iops = { 535 #if LINUX_VERSION_CODE < KERNEL_VERSION 535 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 536 536 .revalidate = sf_inode_revalidate 537 537 #else … … 542 542 543 543 544 #if LINUX_VERSION_CODE >= KERNEL_VERSION 544 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 545 545 static int 546 546 sf_readpage(struct file *file, struct page *page) 547 547 { 548 548 struct inode *inode = file->f_dentry->d_inode; 549 struct sf_glob_info *sf_g = GET_GLOB_INFO 549 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 550 550 struct sf_reg_info *sf_r = file->private_data; 551 551 uint32_t nread = PAGE_SIZE; … … 554 554 int ret; 555 555 556 TRACE 556 TRACE(); 557 557 558 558 buf = kmap(page); 559 ret = sf_reg_read_aux 559 ret = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off); 560 560 if (ret) { 561 kunmap 561 kunmap(page); 562 562 if (PageLocked(page)) 563 563 unlock_page(page); 564 564 return ret; 565 565 } 566 BUG_ON 566 BUG_ON(nread > PAGE_SIZE); 567 567 memset(&buf[nread], 0, PAGE_SIZE - nread); 568 flush_dcache_page 569 kunmap 568 flush_dcache_page(page); 569 kunmap(page); 570 570 SetPageUptodate(page); 571 571 unlock_page(page); … … 578 578 struct address_space *mapping = page->mapping; 579 579 struct inode *inode = mapping->host; 580 struct sf_glob_info *sf_g = GET_GLOB_INFO 581 struct sf_inode_info *sf_i = GET_INODE_INFO 580 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 581 struct sf_inode_info *sf_i = GET_INODE_INFO(inode); 582 582 struct file *file = sf_i->file; 583 583 struct sf_reg_info *sf_r = file->private_data; … … 588 588 int err; 589 589 590 TRACE 590 TRACE(); 591 591 592 592 if (page->index >= end_index) … … 595 595 buf = kmap(page); 596 596 597 err = sf_reg_write_aux 597 err = sf_reg_write_aux(__func__, sf_g, sf_r, buf, &nwritten, off); 598 598 if (err < 0) { 599 599 ClearPageUptodate(page); … … 614 614 } 615 615 616 # if LINUX_VERSION_CODE >= KERNEL_VERSION 616 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) 617 617 int 618 618 sf_write_begin(struct file *file, struct address_space *mapping, loff_t pos, 619 619 unsigned len, unsigned flags, struct page **pagep, void **fsdata) 620 620 { 621 TRACE 621 TRACE(); 622 622 623 623 return simple_write_begin(file, mapping, pos, len, flags, pagep, fsdata); … … 629 629 { 630 630 struct inode *inode = mapping->host; 631 struct sf_glob_info *sf_g = GET_GLOB_INFO 631 struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb); 632 632 struct sf_reg_info *sf_r = file->private_data; 633 633 void *buf; … … 636 636 int err; 637 637 638 TRACE 638 TRACE(); 639 639 640 640 buf = kmap(page); 641 err = sf_reg_write_aux 641 err = sf_reg_write_aux(__func__, sf_g, sf_r, buf+from, &nwritten, pos); 642 642 kunmap(page); 643 643 … … 662 662 .readpage = sf_readpage, 663 663 .writepage = sf_writepage, 664 # if LINUX_VERSION_CODE >= KERNEL_VERSION 664 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) 665 665 .write_begin = sf_write_begin, 666 666 .write_end = sf_write_end, -
trunk/src/VBox/Additions/linux/sharedfolders/utils.c
r30150 r30153 35 35 */ 36 36 37 #if LINUX_VERSION_CODE < KERNEL_VERSION 37 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 38 38 static void 39 sf_ftime_from_timespec 40 { 41 int64_t t = RTTimeSpecGetNano 42 43 do_div 39 sf_ftime_from_timespec(time_t *time, RTTIMESPEC *ts) 40 { 41 int64_t t = RTTimeSpecGetNano(ts); 42 43 do_div(t, 1000000000); 44 44 *time = t; 45 45 } 46 46 47 47 static void 48 sf_timespec_from_ftime 48 sf_timespec_from_ftime(RTTIMESPEC *ts, time_t *time) 49 49 { 50 50 int64_t t = 1000000000 * *time; 51 RTTimeSpecSetNano 51 RTTimeSpecSetNano(ts, t); 52 52 } 53 53 #else /* >= 2.6.0 */ 54 54 static void 55 sf_ftime_from_timespec 56 { 57 int64_t t = RTTimeSpecGetNano 55 sf_ftime_from_timespec(struct timespec *tv, RTTIMESPEC *ts) 56 { 57 int64_t t = RTTimeSpecGetNano(ts); 58 58 int64_t nsec; 59 59 60 nsec = do_div 60 nsec = do_div(t, 1000000000); 61 61 tv->tv_sec = t; 62 62 tv->tv_nsec = nsec; … … 64 64 65 65 static void 66 sf_timespec_from_ftime 66 sf_timespec_from_ftime(RTTIMESPEC *ts, struct timespec *tv) 67 67 { 68 68 int64_t t = (int64_t)tv->tv_nsec + (int64_t)tv->tv_sec * 1000000000; 69 RTTimeSpecSetNano 69 RTTimeSpecSetNano(ts, t); 70 70 } 71 71 #endif /* >= 2.6.0 */ … … 73 73 /* set [inode] attributes based on [info], uid/gid based on [sf_g] */ 74 74 void 75 sf_init_inode 75 sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode, 76 76 RTFSOBJINFO *info) 77 77 { … … 80 80 int mode; 81 81 82 TRACE 82 TRACE(); 83 83 84 84 attr = &info->Attr; 85 is_dir = RTFS_IS_DIRECTORY 85 is_dir = RTFS_IS_DIRECTORY(attr->fMode); 86 86 87 87 #define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0; 88 mode = mode_set 89 mode |= mode_set 90 91 mode |= mode_set 92 mode |= mode_set 93 mode |= mode_set 94 95 mode |= mode_set 96 mode |= mode_set 97 mode |= mode_set 98 99 mode |= mode_set 100 mode |= mode_set 101 mode |= mode_set 88 mode = mode_set(ISUID); 89 mode |= mode_set(ISGID); 90 91 mode |= mode_set(IRUSR); 92 mode |= mode_set(IWUSR); 93 mode |= mode_set(IXUSR); 94 95 mode |= mode_set(IRGRP); 96 mode |= mode_set(IWGRP); 97 mode |= mode_set(IXGRP); 98 99 mode |= mode_set(IROTH); 100 mode |= mode_set(IWOTH); 101 mode |= mode_set(IXOTH); 102 102 #undef mode_set 103 103 104 #if LINUX_VERSION_CODE >= KERNEL_VERSION 104 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 105 105 inode->i_mapping->a_ops = &sf_reg_aops; 106 106 inode->i_mapping->backing_dev_info = &sf_g->bdi; … … 129 129 inode->i_gid = sf_g->gid; 130 130 inode->i_size = info->cbObject; 131 #if LINUX_VERSION_CODE < KERNEL_VERSION 131 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6) 132 132 inode->i_blksize = 4096; 133 133 #endif 134 #if LINUX_VERSION_CODE >= KERNEL_VERSION 134 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11) 135 135 inode->i_blkbits = 12; 136 136 #endif … … 138 138 inode->i_blocks = (info->cbAllocated + 511) / 512; 139 139 140 sf_ftime_from_timespec 141 sf_ftime_from_timespec 142 sf_ftime_from_timespec 140 sf_ftime_from_timespec(&inode->i_atime, &info->AccessTime); 141 sf_ftime_from_timespec(&inode->i_ctime, &info->ChangeTime); 142 sf_ftime_from_timespec(&inode->i_mtime, &info->ModificationTime); 143 143 } 144 144 145 145 int 146 sf_stat 147 146 sf_stat(const char *caller, struct sf_glob_info *sf_g, 147 SHFLSTRING *path, RTFSOBJINFO *result, int ok_to_fail) 148 148 { 149 149 int rc; 150 150 SHFLCREATEPARMS params; 151 151 152 TRACE 152 TRACE(); 153 153 154 154 RT_ZERO(params); … … 156 156 LogFunc(("sf_stat: calling vboxCallCreate, file %s, flags %#x\n", 157 157 path->String.utf8, params.CreateFlags)); 158 rc = vboxCallCreate 159 if (RT_FAILURE 158 rc = vboxCallCreate(&client_handle, &sf_g->map, path, ¶ms); 159 if (RT_FAILURE(rc)) { 160 160 LogFunc(("vboxCallCreate(%s) failed. caller=%s, rc=%Rrc\n", 161 161 path->String.utf8, rc, caller)); … … 182 182 update inode attributes */ 183 183 int 184 sf_inode_revalidate 184 sf_inode_revalidate(struct dentry *dentry) 185 185 { 186 186 int err; … … 189 189 RTFSOBJINFO info; 190 190 191 TRACE 191 TRACE(); 192 192 if (!dentry || !dentry->d_inode) { 193 193 LogFunc(("no dentry(%p) or inode(%p)\n", dentry, dentry->d_inode)); … … 195 195 } 196 196 197 sf_g = GET_GLOB_INFO 198 sf_i = GET_INODE_INFO 197 sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb); 198 sf_i = GET_INODE_INFO(dentry->d_inode); 199 199 200 200 #if 0 201 printk 202 203 204 205 #endif 206 207 BUG_ON 208 BUG_ON 201 printk("%s called by %p:%p\n", 202 sf_i->path->String.utf8, 203 __builtin_return_address (0), 204 __builtin_return_address (1)); 205 #endif 206 207 BUG_ON(!sf_g); 208 BUG_ON(!sf_i); 209 209 210 210 if (!sf_i->force_restat) { … … 214 214 } 215 215 216 err = sf_stat 216 err = sf_stat(__func__, sf_g, sf_i->path, &info, 1); 217 217 if (err) { 218 218 return err; … … 220 220 221 221 dentry->d_time = jiffies; 222 sf_init_inode 222 sf_init_inode(sf_g, dentry->d_inode, &info); 223 223 return 0; 224 224 } … … 228 228 [sf_inode_revalidate] */ 229 229 static int 230 #if LINUX_VERSION_CODE < KERNEL_VERSION 231 sf_dentry_revalidate 230 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 231 sf_dentry_revalidate(struct dentry *dentry, int flags) 232 232 #else 233 sf_dentry_revalidate 234 #endif 235 { 236 TRACE 237 if (sf_inode_revalidate 233 sf_dentry_revalidate(struct dentry *dentry, struct nameidata *nd) 234 #endif 235 { 236 TRACE(); 237 if (sf_inode_revalidate(dentry)) { 238 238 return 0; 239 239 } … … 245 245 has inode at all) from these new attributes we derive [kstat] via 246 246 [generic_fillattr] */ 247 #if LINUX_VERSION_CODE >= KERNEL_VERSION 247 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 248 248 int 249 sf_getattr 249 sf_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat) 250 250 { 251 251 int err; 252 252 253 TRACE 254 err = sf_inode_revalidate 253 TRACE(); 254 err = sf_inode_revalidate(dentry); 255 255 if (err) { 256 256 return err; 257 257 } 258 258 259 generic_fillattr 259 generic_fillattr(dentry->d_inode, kstat); 260 260 return 0; 261 261 } 262 262 263 263 int 264 sf_setattr 264 sf_setattr(struct dentry *dentry, struct iattr *iattr) 265 265 { 266 266 struct sf_glob_info *sf_g; … … 271 271 int rc, err; 272 272 273 TRACE 274 275 sf_g = GET_GLOB_INFO 276 sf_i = GET_INODE_INFO 273 TRACE(); 274 275 sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb); 276 sf_i = GET_INODE_INFO(dentry->d_inode); 277 277 err = 0; 278 278 … … 287 287 params.CreateFlags |= SHFL_CF_ACCESS_WRITE; 288 288 289 rc = vboxCallCreate 290 if (RT_FAILURE 289 rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, ¶ms); 290 if (RT_FAILURE(rc)) { 291 291 LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n", 292 292 sf_i->path->String.utf8, rc)); … … 310 310 if (iattr->ia_valid & ATTR_MODE) 311 311 { 312 info.Attr.fMode = mode_set 313 info.Attr.fMode |= mode_set 314 info.Attr.fMode |= mode_set 315 info.Attr.fMode |= mode_set 316 info.Attr.fMode |= mode_set 317 info.Attr.fMode |= mode_set 318 info.Attr.fMode |= mode_set 319 info.Attr.fMode |= mode_set 320 info.Attr.fMode |= mode_set 321 info.Attr.fMode |= mode_set 322 info.Attr.fMode |= mode_set 312 info.Attr.fMode = mode_set(ISUID); 313 info.Attr.fMode |= mode_set(ISGID); 314 info.Attr.fMode |= mode_set(IRUSR); 315 info.Attr.fMode |= mode_set(IWUSR); 316 info.Attr.fMode |= mode_set(IXUSR); 317 info.Attr.fMode |= mode_set(IRGRP); 318 info.Attr.fMode |= mode_set(IWGRP); 319 info.Attr.fMode |= mode_set(IXGRP); 320 info.Attr.fMode |= mode_set(IROTH); 321 info.Attr.fMode |= mode_set(IWOTH); 322 info.Attr.fMode |= mode_set(IXOTH); 323 323 324 324 if (iattr->ia_mode & S_IFDIR) … … 329 329 330 330 if (iattr->ia_valid & ATTR_ATIME) 331 sf_timespec_from_ftime 331 sf_timespec_from_ftime(&info.AccessTime, &iattr->ia_atime); 332 332 if (iattr->ia_valid & ATTR_MTIME) 333 sf_timespec_from_ftime 333 sf_timespec_from_ftime(&info.ModificationTime, &iattr->ia_mtime); 334 334 /* ignore ctime (inode change time) as it can't be set from userland anyway */ 335 335 … … 338 338 SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer, 339 339 (PSHFLDIRINFO)&info); 340 if (RT_FAILURE 340 if (RT_FAILURE(rc)) { 341 341 LogFunc(("vboxCallFSInfo(%s, FILE) failed rc=%Rrc\n", 342 342 sf_i->path->String.utf8, rc)); … … 354 354 SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer, 355 355 (PSHFLDIRINFO)&info); 356 if (RT_FAILURE 356 if (RT_FAILURE(rc)) { 357 357 LogFunc(("vboxCallFSInfo(%s, SIZE) failed rc=%Rrc\n", 358 358 sf_i->path->String.utf8, rc)); … … 362 362 } 363 363 364 rc = vboxCallClose 365 if (RT_FAILURE 364 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 365 if (RT_FAILURE(rc)) 366 366 { 367 367 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", … … 369 369 } 370 370 371 return sf_inode_revalidate 371 return sf_inode_revalidate(dentry); 372 372 373 373 fail1: 374 rc = vboxCallClose 375 if (RT_FAILURE 374 rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle); 375 if (RT_FAILURE(rc)) 376 376 { 377 377 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n", … … 384 384 385 385 static int 386 sf_make_path 386 sf_make_path(const char *caller, struct sf_inode_info *sf_i, 387 387 const char *d_name, size_t d_len, SHFLSTRING **result) 388 388 { … … 394 394 int is_root = 0; 395 395 396 TRACE 396 TRACE(); 397 397 p_len = sf_i->path->u16Length; 398 398 p_name = sf_i->path->String.utf8; … … 411 411 } 412 412 413 shflstring_len = offsetof 414 tmp = kmalloc 413 shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len; 414 tmp = kmalloc(shflstring_len, GFP_KERNEL); 415 415 if (!tmp) { 416 416 LogRelFunc(("kmalloc failed, caller=%s\n", caller)); … … 421 421 422 422 if (is_root) { 423 memcpy 423 memcpy(tmp->String.utf8, d_name, d_len + 1); 424 424 } 425 425 else { 426 426 dst = tmp->String.utf8; 427 memcpy 427 memcpy(dst, p_name, p_len); 428 428 dst += p_len; *dst++ = '/'; 429 memcpy 429 memcpy(dst, d_name, d_len); 430 430 dst[d_len] = 0; 431 431 } … … 439 439 [sf_make_path] which will allocate SHFLSTRING and fill it in */ 440 440 int 441 sf_path_from_dentry 441 sf_path_from_dentry(const char *caller, struct sf_glob_info *sf_g, 442 442 struct sf_inode_info *sf_i, struct dentry *dentry, 443 443 SHFLSTRING **result) … … 449 449 size_t len = 0; 450 450 451 TRACE 451 TRACE(); 452 452 d_name = dentry->d_name.name; 453 453 d_len = dentry->d_name.len; … … 462 462 463 463 out_bound_len = PATH_MAX; 464 out = kmalloc 464 out = kmalloc(out_bound_len, GFP_KERNEL); 465 465 name = out; 466 466 … … 471 471 int nb; 472 472 473 nb = sf_g->nls->char2uni 473 nb = sf_g->nls->char2uni(in, in_len, &uni); 474 474 if (nb < 0) { 475 475 LogFunc(("nls->char2uni failed %x %d\n", … … 481 481 in += nb; 482 482 483 #if LINUX_VERSION_CODE >= KERNEL_VERSION 484 nb = utf32_to_utf8 483 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31) 484 nb = utf32_to_utf8(uni, out, out_bound_len); 485 485 #else 486 nb = utf8_wctomb 486 nb = utf8_wctomb(out, uni, out_bound_len); 487 487 #endif 488 488 if (nb < 0) { … … 509 509 } 510 510 511 err = sf_make_path 511 err = sf_make_path(caller, sf_i, name, len, result); 512 512 if (name != d_name) { 513 kfree 513 kfree(name); 514 514 } 515 515 return err; 516 516 517 517 fail1: 518 kfree 518 kfree(name); 519 519 return err; 520 520 } 521 521 522 522 int 523 sf_nlscpy 523 sf_nlscpy(struct sf_glob_info *sf_g, 524 524 char *name, size_t name_bound_len, 525 525 const unsigned char *utf8_name, size_t utf8_len) … … 543 543 wchar_t uni; 544 544 545 #if LINUX_VERSION_CODE >= KERNEL_VERSION 546 nb = utf8_to_utf32 545 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31) 546 nb = utf8_to_utf32(in, in_bound_len, &uni); 547 547 #else 548 nb = utf8_mbtowc 548 nb = utf8_mbtowc(&uni, in, in_bound_len); 549 549 #endif 550 550 if (nb < 0) { … … 556 556 in_bound_len -= nb; 557 557 558 nb = sf_g->nls->uni2char 558 nb = sf_g->nls->uni2char(uni, out, out_bound_len); 559 559 if (nb < 0) { 560 560 LogFunc(("nls->uni2char failed(%s) %x:%d\n", … … 575 575 } 576 576 else { 577 memcpy 577 memcpy(name, utf8_name, utf8_len + 1); 578 578 } 579 579 return 0; … … 582 582 583 583 static struct sf_dir_buf * 584 sf_dir_buf_alloc 584 sf_dir_buf_alloc(void) 585 585 { 586 586 struct sf_dir_buf *b; 587 587 588 TRACE 589 b = kmalloc (sizeof(*b), GFP_KERNEL);588 TRACE(); 589 b = kmalloc(sizeof(*b), GFP_KERNEL); 590 590 if (!b) { 591 591 LogRelFunc(("could not alloc directory buffer\n")); … … 594 594 595 595 #ifdef USE_VMALLOC 596 b->buf = vmalloc 596 b->buf = vmalloc(16384); 597 597 #else 598 b->buf = kmalloc 598 b->buf = kmalloc(16384, GFP_KERNEL); 599 599 #endif 600 600 if (!b->buf) { 601 kfree 601 kfree(b); 602 602 LogRelFunc(("could not alloc directory buffer storage\n")); 603 603 return NULL; 604 604 } 605 605 606 INIT_LIST_HEAD 606 INIT_LIST_HEAD(&b->head); 607 607 b->nb_entries = 0; 608 608 b->used_bytes = 0; … … 612 612 613 613 static void 614 sf_dir_buf_free 615 { 616 BUG_ON 617 618 TRACE 619 list_del 614 sf_dir_buf_free(struct sf_dir_buf *b) 615 { 616 BUG_ON(!b || !b->buf); 617 618 TRACE(); 619 list_del(&b->head); 620 620 #ifdef USE_VMALLOC 621 vfree 621 vfree(b->buf); 622 622 #else 623 kfree 624 #endif 625 kfree 623 kfree(b->buf); 624 #endif 625 kfree(b); 626 626 } 627 627 628 628 void 629 sf_dir_info_free 629 sf_dir_info_free(struct sf_dir_info *p) 630 630 { 631 631 struct list_head *list, *pos, *tmp; 632 632 633 TRACE 633 TRACE(); 634 634 list = &p->info_list; 635 list_for_each_safe 635 list_for_each_safe(pos, tmp, list) { 636 636 struct sf_dir_buf *b; 637 637 638 b = list_entry 639 sf_dir_buf_free 640 } 641 kfree 638 b = list_entry(pos, struct sf_dir_buf, head); 639 sf_dir_buf_free(b); 640 } 641 kfree(p); 642 642 } 643 643 … … 646 646 { 647 647 struct list_head *list, *pos, *tmp; 648 TRACE 648 TRACE(); 649 649 list = &p->info_list; 650 list_for_each_safe 650 list_for_each_safe(pos, tmp, list) { 651 651 struct sf_dir_buf *b; 652 b = list_entry 652 b = list_entry(pos, struct sf_dir_buf, head); 653 653 b->nb_entries = 0; 654 654 b->used_bytes = 0; … … 658 658 659 659 struct sf_dir_info * 660 sf_dir_info_alloc 660 sf_dir_info_alloc(void) 661 661 { 662 662 struct sf_dir_info *p; 663 663 664 TRACE 665 p = kmalloc (sizeof(*p), GFP_KERNEL);664 TRACE(); 665 p = kmalloc(sizeof(*p), GFP_KERNEL); 666 666 if (!p) { 667 667 LogRelFunc(("could not alloc directory info\n")); … … 669 669 } 670 670 671 INIT_LIST_HEAD 671 INIT_LIST_HEAD(&p->info_list); 672 672 return p; 673 673 } 674 674 675 675 static struct sf_dir_buf * 676 sf_get_empty_dir_buf 676 sf_get_empty_dir_buf(struct sf_dir_info *sf_d) 677 677 { 678 678 struct list_head *list, *pos; 679 679 680 680 list = &sf_d->info_list; 681 list_for_each 681 list_for_each(pos, list) { 682 682 struct sf_dir_buf *b; 683 683 684 b = list_entry 684 b = list_entry(pos, struct sf_dir_buf, head); 685 685 if (!b) { 686 686 return NULL; … … 697 697 698 698 int 699 sf_dir_read_all 699 sf_dir_read_all(struct sf_glob_info *sf_g, struct sf_inode_info *sf_i, 700 700 struct sf_dir_info *sf_d, SHFLHANDLE handle) 701 701 { … … 704 704 struct sf_dir_buf *b; 705 705 706 TRACE 707 err = sf_make_path 706 TRACE(); 707 err = sf_make_path(__func__, sf_i, "*", 1, &mask); 708 708 if (err) { 709 709 goto fail0; … … 716 716 uint32_t nb_ents; 717 717 718 b = sf_get_empty_dir_buf 718 b = sf_get_empty_dir_buf(sf_d); 719 719 if (!b) { 720 b = sf_dir_buf_alloc 720 b = sf_dir_buf_alloc(); 721 721 if (!b) { 722 722 err = -ENOMEM; … … 724 724 goto fail1; 725 725 } 726 list_add 726 list_add(&b->head, &sf_d->info_list); 727 727 } 728 728 … … 730 730 buf_size = b->free_bytes; 731 731 732 rc = vboxCallDirInfo ( 733 &client_handle, 734 &sf_g->map, 735 handle, 736 mask, 737 0, 738 0, 739 &buf_size, 740 buf, 741 &nb_ents 742 ); 732 rc = vboxCallDirInfo(&client_handle, &sf_g->map, handle, mask, 733 0, 0, &buf_size, buf, &nb_ents); 743 734 switch (rc) { 744 735 case VINF_SUCCESS: … … 753 744 754 745 default: 755 err = -RTErrConvertToErrno 746 err = -RTErrConvertToErrno(rc); 756 747 LogFunc(("vboxCallDirInfo failed rc=%Rrc\n", rc)); 757 748 goto fail1; … … 762 753 b->used_bytes += buf_size; 763 754 764 if (RT_FAILURE 755 if (RT_FAILURE(rc)) 765 756 break; 766 757 } … … 768 759 769 760 fail1: 770 kfree 761 kfree(mask); 771 762 fail0: 772 763 return err; … … 780 771 int rc; 781 772 782 sf_g = GET_GLOB_INFO 773 sf_g = GET_GLOB_INFO(sb); 783 774 cbBuffer = sizeof(SHFLVolumeInfo); 784 775 rc = vboxCallFSInfo(&client_handle, &sf_g->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME, … … 812 803 int rc = 0; 813 804 814 #if LINUX_VERSION_CODE >= KERNEL_VERSION 805 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 815 806 sf_g->bdi.ra_pages = 0; /* No readahead */ 816 # if LINUX_VERSION_CODE >= KERNEL_VERSION 807 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12) 817 808 sf_g->bdi.capabilities = BDI_CAP_MAP_DIRECT /* MAP_SHARED */ 818 809 | BDI_CAP_MAP_COPY /* MAP_PRIVATE */ … … 821 812 | BDI_CAP_EXEC_MAP; /* can be mapped for execution */ 822 813 # endif /* >= 2.6.12 */ 823 # if LINUX_VERSION_CODE >= KERNEL_VERSION 814 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) 824 815 rc = bdi_init(&sf_g->bdi); 825 # if LINUX_VERSION_CODE >= KERNEL_VERSION 816 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26) 826 817 if (!rc) 827 818 rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%s", name); … … 834 825 void sf_done_backing_dev(struct sf_glob_info *sf_g) 835 826 { 836 #if LINUX_VERSION_CODE >= KERNEL_VERSION 827 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) 837 828 bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */ 838 829 #endif -
trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c
r28998 r30153 43 43 // #define wchar_t linux_wchar_t 44 44 45 MODULE_DESCRIPTION 46 MODULE_AUTHOR 47 MODULE_LICENSE 45 MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access"); 46 MODULE_AUTHOR(VBOX_VENDOR); 47 MODULE_LICENSE("GPL"); 48 48 #ifdef MODULE_VERSION 49 49 MODULE_VERSION(VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")"); … … 62 62 /* allocate global info, try to map host share */ 63 63 static int 64 sf_glob_alloc 64 sf_glob_alloc(struct vbsf_mount_info_new *info, struct sf_glob_info **sf_gp) 65 65 { 66 66 int err, rc; … … 69 69 struct sf_glob_info *sf_g; 70 70 71 TRACE 72 sf_g = kmalloc (sizeof(*sf_g), GFP_KERNEL);71 TRACE(); 72 sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL); 73 73 if (!sf_g) { 74 74 err = -ENOMEM; … … 99 99 } 100 100 101 info->name[sizeof 102 info->nls_name[sizeof 103 104 name_len = strlen 101 info->name[sizeof(info->name) - 1] = 0; 102 info->nls_name[sizeof(info->nls_name) - 1] = 0; 103 104 name_len = strlen(info->name); 105 105 if (name_len > 0xfffe) { 106 106 err = -ENAMETOOLONG; … … 109 109 } 110 110 111 str_len = offsetof 112 str_name = kmalloc 111 str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1; 112 str_name = kmalloc(str_len, GFP_KERNEL); 113 113 if (!str_name) { 114 114 err = -ENOMEM; … … 119 119 str_name->u16Length = name_len; 120 120 str_name->u16Size = name_len + 1; 121 memcpy 122 123 if (info->nls_name[0] && strcmp 124 sf_g->nls = load_nls 121 memcpy(str_name->String.utf8, info->name, name_len + 1); 122 123 if (info->nls_name[0] && strcmp(info->nls_name, "utf8")) { 124 sf_g->nls = load_nls(info->nls_name); 125 125 if (!sf_g->nls) { 126 126 err = -EINVAL; … … 133 133 } 134 134 135 rc = vboxCallMapFolder 136 kfree 137 138 if (RT_FAILURE 135 rc = vboxCallMapFolder(&client_handle, str_name, &sf_g->map); 136 kfree(str_name); 137 138 if (RT_FAILURE(rc)) { 139 139 err = -EPROTO; 140 140 LogFunc(("vboxCallMapFolder failed rc=%d\n", rc)); … … 165 165 fail2: 166 166 if (sf_g->nls) { 167 unload_nls 167 unload_nls(sf_g->nls); 168 168 } 169 169 fail1: 170 kfree 170 kfree(sf_g); 171 171 fail0: 172 172 return err; … … 175 175 /* unmap the share and free global info [sf_g] */ 176 176 static void 177 sf_glob_free 177 sf_glob_free(struct sf_glob_info *sf_g) 178 178 { 179 179 int rc; 180 180 181 TRACE 182 rc = vboxCallUnmapFolder 183 if (RT_FAILURE 181 TRACE(); 182 rc = vboxCallUnmapFolder(&client_handle, &sf_g->map); 183 if (RT_FAILURE(rc)) { 184 184 LogFunc(("vboxCallUnmapFolder failed rc=%d\n", rc)); 185 185 } 186 186 187 187 if (sf_g->nls) { 188 unload_nls 189 } 190 kfree 188 unload_nls(sf_g->nls); 189 } 190 kfree(sf_g); 191 191 } 192 192 … … 201 201 should respect [flags] */ 202 202 static int 203 sf_read_super_aux 203 sf_read_super_aux(struct super_block *sb, void *data, int flags) 204 204 { 205 205 int err; … … 211 211 struct vbsf_mount_info_new *info; 212 212 213 TRACE 213 TRACE(); 214 214 if (!data) { 215 215 LogFunc(("no mount info specified\n")); … … 224 224 } 225 225 226 err = sf_glob_alloc 226 err = sf_glob_alloc(info, &sf_g); 227 227 if (err) { 228 228 goto fail0; 229 229 } 230 230 231 sf_i = kmalloc 231 sf_i = kmalloc(sizeof (*sf_i), GFP_KERNEL); 232 232 if (!sf_i) { 233 233 err = -ENOMEM; 234 LogRelFunc 234 LogRelFunc(("could not allocate memory for root inode info\n")); 235 235 goto fail1; 236 236 } 237 237 238 238 sf_i->handle = SHFL_HANDLE_NIL; 239 sf_i->path = kmalloc (sizeof(SHFLSTRING) + 1, GFP_KERNEL);239 sf_i->path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL); 240 240 if (!sf_i->path) { 241 241 err = -ENOMEM; 242 LogRelFunc 242 LogRelFunc(("could not allocate memory for root inode path\n")); 243 243 goto fail2; 244 244 } … … 249 249 sf_i->path->String.utf8[1] = 0; 250 250 251 err = sf_stat 251 err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0); 252 252 if (err) { 253 253 LogFunc(("could not stat root of share\n")); … … 257 257 sb->s_magic = 0xface; 258 258 sb->s_blocksize = 1024; 259 #if LINUX_VERSION_CODE >= KERNEL_VERSION 259 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 3) 260 260 /* Required for seek/sendfile. 261 261 * … … 273 273 sb->s_op = &sf_super_ops; 274 274 275 #if LINUX_VERSION_CODE >= KERNEL_VERSION 276 iroot = iget_locked 275 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 276 iroot = iget_locked(sb, 0); 277 277 #else 278 iroot = iget 278 iroot = iget(sb, 0); 279 279 #endif 280 280 if (!iroot) { … … 290 290 } 291 291 292 sf_init_inode 293 SET_INODE_INFO 294 295 #if LINUX_VERSION_CODE >= KERNEL_VERSION 292 sf_init_inode(sf_g, iroot, &fsinfo); 293 SET_INODE_INFO(iroot, sf_i); 294 295 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25) 296 296 unlock_new_inode(iroot); 297 297 #endif 298 298 299 droot = d_alloc_root 299 droot = d_alloc_root(iroot); 300 300 if (!droot) { 301 301 err = -ENOMEM; /* XXX */ … … 305 305 306 306 sb->s_root = droot; 307 SET_GLOB_INFO 307 SET_GLOB_INFO(sb, sf_g); 308 308 return 0; 309 309 … … 311 311 sf_done_backing_dev(sf_g); 312 312 fail4: 313 iput 313 iput(iroot); 314 314 fail3: 315 kfree 315 kfree(sf_i->path); 316 316 fail2: 317 kfree 317 kfree(sf_i); 318 318 fail1: 319 sf_glob_free 319 sf_glob_free(sf_g); 320 320 fail0: 321 321 return err; 322 322 } 323 323 324 #if LINUX_VERSION_CODE < KERNEL_VERSION 324 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 325 325 static struct super_block * 326 sf_read_super_24 326 sf_read_super_24(struct super_block *sb, void *data, int flags) 327 327 { 328 328 int err; 329 329 330 TRACE 331 err = sf_read_super_aux 330 TRACE(); 331 err = sf_read_super_aux(sb, data, flags); 332 332 if (err) { 333 333 return NULL; … … 341 341 resources associated with this [inode] must be cleared here */ 342 342 static void 343 sf_clear_inode 343 sf_clear_inode(struct inode *inode) 344 344 { 345 345 struct sf_inode_info *sf_i; 346 346 347 TRACE 348 sf_i = GET_INODE_INFO 347 TRACE(); 348 sf_i = GET_INODE_INFO(inode); 349 349 if (!sf_i) { 350 350 return; 351 351 } 352 352 353 BUG_ON 354 kfree 355 kfree 356 SET_INODE_INFO 353 BUG_ON(!sf_i->path); 354 kfree(sf_i->path); 355 kfree(sf_i); 356 SET_INODE_INFO(inode, NULL); 357 357 } 358 358 … … 361 361 hence we can't do anything here, and let lookup/whatever with the 362 362 job to properly fill then [inode] */ 363 #if LINUX_VERSION_CODE < KERNEL_VERSION 363 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25) 364 364 static void 365 sf_read_inode 365 sf_read_inode(struct inode *inode) 366 366 { 367 367 } … … 371 371 the folder and free [sf_g] */ 372 372 static void 373 sf_put_super 373 sf_put_super(struct super_block *sb) 374 374 { 375 375 struct sf_glob_info *sf_g; 376 376 377 sf_g = GET_GLOB_INFO 378 BUG_ON 377 sf_g = GET_GLOB_INFO(sb); 378 BUG_ON(!sf_g); 379 379 sf_done_backing_dev(sf_g); 380 sf_glob_free 381 } 382 383 #if LINUX_VERSION_CODE < KERNEL_VERSION 384 static int 385 sf_statfs 380 sf_glob_free(sf_g); 381 } 382 383 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) 384 static int 385 sf_statfs(struct super_block *sb, STRUCT_STATFS *stat) 386 386 { 387 387 return sf_get_volume_info(sb, stat); … … 389 389 #else 390 390 static int 391 sf_statfs 391 sf_statfs(struct dentry *dentry, STRUCT_STATFS *stat) 392 392 { 393 393 struct super_block *sb = dentry->d_inode->i_sb; … … 397 397 398 398 static int 399 sf_remount_fs 400 { 401 TRACE 399 sf_remount_fs(struct super_block *sb, int *flags, char *data) 400 { 401 TRACE(); 402 402 return -ENOSYS; 403 403 } … … 405 405 static struct super_operations sf_super_ops = { 406 406 .clear_inode = sf_clear_inode, 407 #if LINUX_VERSION_CODE < KERNEL_VERSION 407 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25) 408 408 .read_inode = sf_read_inode, 409 409 #endif … … 413 413 }; 414 414 415 #if LINUX_VERSION_CODE < KERNEL_VERSION 416 static DECLARE_FSTYPE 415 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 416 static DECLARE_FSTYPE(vboxsf_fs_type, "vboxsf", sf_read_super_24, 0); 417 417 #else 418 418 static int 419 sf_read_super_26 419 sf_read_super_26(struct super_block *sb, void *data, int flags) 420 420 { 421 421 int err; 422 422 423 TRACE 424 err = sf_read_super_aux 423 TRACE(); 424 err = sf_read_super_aux(sb, data, flags); 425 425 if (err) { 426 printk 426 printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err); 427 427 } 428 428 return err; 429 429 } 430 430 431 #if LINUX_VERSION_CODE < KERNEL_VERSION 431 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18) 432 432 static struct super_block * 433 sf_get_sb 433 sf_get_sb(struct file_system_type *fs_type, int flags, 434 434 const char *dev_name, void *data) 435 435 { 436 TRACE 437 return get_sb_nodev 436 TRACE(); 437 return get_sb_nodev(fs_type, flags, data, sf_read_super_26); 438 438 } 439 439 #else 440 440 static int 441 sf_get_sb 441 sf_get_sb(struct file_system_type *fs_type, int flags, 442 442 const char *dev_name, void *data, struct vfsmount *mnt) 443 443 { 444 TRACE 445 return get_sb_nodev 444 TRACE(); 445 return get_sb_nodev(fs_type, flags, data, sf_read_super_26, mnt); 446 446 } 447 447 #endif … … 457 457 /* Module initialization/finalization handlers */ 458 458 static int __init 459 init 459 init(void) 460 460 { 461 461 int rcVBox; … … 463 463 int err; 464 464 465 TRACE 466 467 if (sizeof 468 printk 469 470 471 472 465 TRACE(); 466 467 if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE) { 468 printk(KERN_ERR 469 "Mount information structure is too large %lu\n" 470 "Must be less than or equal to %lu\n", 471 (unsigned long)sizeof (struct vbsf_mount_info_new), 472 (unsigned long)PAGE_SIZE); 473 473 return -EINVAL; 474 474 } 475 475 476 err = register_filesystem 476 err = register_filesystem(&vboxsf_fs_type); 477 477 if (err) { 478 478 LogFunc(("register_filesystem err=%d\n", err)); … … 480 480 } 481 481 482 rcVBox = vboxInit 483 if (RT_FAILURE 484 LogRelFunc 482 rcVBox = vboxInit(); 483 if (RT_FAILURE(rcVBox)) { 484 LogRelFunc(("vboxInit failed, rc=%d\n", rcVBox)); 485 485 rcRet = -EPROTO; 486 486 goto fail0; 487 487 } 488 488 489 rcVBox = vboxConnect 490 if (RT_FAILURE 491 LogRelFunc 489 rcVBox = vboxConnect(&client_handle); 490 if (RT_FAILURE(rcVBox)) { 491 LogRelFunc(("vboxConnect failed, rc=%d\n", rcVBox)); 492 492 rcRet = -EPROTO; 493 493 goto fail1; 494 494 } 495 495 496 rcVBox = vboxCallSetUtf8 497 if (RT_FAILURE 498 LogRelFunc 496 rcVBox = vboxCallSetUtf8(&client_handle); 497 if (RT_FAILURE(rcVBox)) { 498 LogRelFunc(("vboxCallSetUtf8 failed, rc=%d\n", rcVBox)); 499 499 rcRet = -EPROTO; 500 500 goto fail2; … … 508 508 509 509 fail2: 510 vboxDisconnect 510 vboxDisconnect(&client_handle); 511 511 fail1: 512 vboxUninit 512 vboxUninit(); 513 513 fail0: 514 unregister_filesystem 514 unregister_filesystem(&vboxsf_fs_type); 515 515 return rcRet; 516 516 } 517 517 518 518 static void __exit 519 fini 520 { 521 TRACE 522 523 vboxDisconnect 524 vboxUninit 525 unregister_filesystem 526 } 527 528 module_init 529 module_exit 519 fini(void) 520 { 521 TRACE(); 522 523 vboxDisconnect(&client_handle); 524 vboxUninit(); 525 unregister_filesystem(&vboxsf_fs_type); 526 } 527 528 module_init(init); 529 module_exit(fini); 530 530 531 531 /* C++ hack */ 532 532 int __gxx_personality_v0 = 0xdeadbeef; 533 534 #if 0535 /* long long hacks (as far as i can see, gcc emits the refs to those536 symbols, notwithstanding the fact that those aren't referenced537 anywhere in the module) */538 void __divdi3 (void)539 {540 elog ("called from %p\n", __builtin_return_address (0));541 BUG ();542 }543 544 void __moddi3 (void)545 {546 elog ("called from %p\n", __builtin_return_address (0));547 BUG ();548 }549 #endif /* 0 */550 533 551 534 /* -
trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h
r30150 r30153 88 88 extern struct address_space_operations sf_reg_aops; 89 89 90 extern void 91 sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode, 92 RTFSOBJINFO *info); 90 extern void sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode, 91 RTFSOBJINFO *info); 93 92 extern int sf_stat(const char *caller, struct sf_glob_info *sf_g, 94 93 SHFLSTRING *path, RTFSOBJINFO *result, int ok_to_fail); … … 114 113 115 114 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 116 # define STRUCT_STATFS struct statfs115 # define STRUCT_STATFS struct statfs 117 116 #else 118 # define STRUCT_STATFS struct kstatfs117 # define STRUCT_STATFS struct kstatfs 119 118 #endif 120 119 int sf_get_volume_info(struct super_block *sb,STRUCT_STATFS *stat); … … 126 125 #endif 127 126 128 #define TRACE() LogFunc 127 #define TRACE() LogFunc(("tracepoint\n")) 129 128 130 129 /* Following casts are here to prevent assignment of void * to 131 130 pointers of arbitrary type */ 132 131 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) 133 # define GET_GLOB_INFO(sb)((struct sf_glob_info *) (sb)->u.generic_sbp)134 # define SET_GLOB_INFO(sb, sf_g) (sb)->u.generic_sbp = sf_g132 # define GET_GLOB_INFO(sb) ((struct sf_glob_info *) (sb)->u.generic_sbp) 133 # define SET_GLOB_INFO(sb, sf_g) (sb)->u.generic_sbp = sf_g 135 134 #else 136 # define GET_GLOB_INFO(sb)((struct sf_glob_info *) (sb)->s_fs_info)137 # define SET_GLOB_INFO(sb, sf_g) (sb)->s_fs_info = sf_g135 # define GET_GLOB_INFO(sb) ((struct sf_glob_info *) (sb)->s_fs_info) 136 # define SET_GLOB_INFO(sb, sf_g) (sb)->s_fs_info = sf_g 138 137 #endif 139 138 140 139 #if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 19) || defined(KERNEL_FC6) 141 140 /* FC6 kernel 2.6.18, vanilla kernel 2.6.19+ */ 142 # define GET_INODE_INFO(i)((struct sf_inode_info *) (i)->i_private)143 # define SET_INODE_INFO(i, sf_i) (i)->i_private = sf_i141 # define GET_INODE_INFO(i) ((struct sf_inode_info *) (i)->i_private) 142 # define SET_INODE_INFO(i, sf_i) (i)->i_private = sf_i 144 143 #else 145 144 /* vanilla kernel up to 2.6.18 */ 146 # define GET_INODE_INFO(i)((struct sf_inode_info *) (i)->u.generic_ip)147 # define SET_INODE_INFO(i, sf_i) (i)->u.generic_ip = sf_i145 # define GET_INODE_INFO(i) ((struct sf_inode_info *) (i)->u.generic_ip) 146 # define SET_INODE_INFO(i, sf_i) (i)->u.generic_ip = sf_i 148 147 #endif 149 148
Note:
See TracChangeset
for help on using the changeset viewer.
