Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/smbfs/dir.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * dir.c 3 * 4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke 5 * Copyright (C) 1997 by Volker Lendecke 6 * 7 * Please add a note about your changes to smbfs in the ChangeLog file. 8 */ 9 10 #include <linux/time.h> 11 #include <linux/errno.h> 12 #include <linux/kernel.h> 13 #include <linux/smp_lock.h> 14 #include <linux/ctype.h> 15 #include <linux/net.h> 16 #include <linux/sched.h> 17 18 #include <linux/smb_fs.h> 19 #include <linux/smb_mount.h> 20 #include <linux/smbno.h> 21 22 #include "smb_debug.h" 23 #include "proto.h" 24 25 static int smb_readdir(struct file *, void *, filldir_t); 26 static int smb_dir_open(struct inode *, struct file *); 27 28 static struct dentry *smb_lookup(struct inode *, struct dentry *, struct nameidata *); 29 static int smb_create(struct inode *, struct dentry *, int, struct nameidata *); 30 static int smb_mkdir(struct inode *, struct dentry *, int); 31 static int smb_rmdir(struct inode *, struct dentry *); 32 static int smb_unlink(struct inode *, struct dentry *); 33 static int smb_rename(struct inode *, struct dentry *, 34 struct inode *, struct dentry *); 35 static int smb_make_node(struct inode *,struct dentry *,int,dev_t); 36 static int smb_link(struct dentry *, struct inode *, struct dentry *); 37 38 const struct file_operations smb_dir_operations = 39 { 40 .llseek = generic_file_llseek, 41 .read = generic_read_dir, 42 .readdir = smb_readdir, 43 .unlocked_ioctl = smb_ioctl, 44 .open = smb_dir_open, 45 }; 46 47 const struct inode_operations smb_dir_inode_operations = 48 { 49 .create = smb_create, 50 .lookup = smb_lookup, 51 .unlink = smb_unlink, 52 .mkdir = smb_mkdir, 53 .rmdir = smb_rmdir, 54 .rename = smb_rename, 55 .getattr = smb_getattr, 56 .setattr = smb_notify_change, 57 }; 58 59 const struct inode_operations smb_dir_inode_operations_unix = 60 { 61 .create = smb_create, 62 .lookup = smb_lookup, 63 .unlink = smb_unlink, 64 .mkdir = smb_mkdir, 65 .rmdir = smb_rmdir, 66 .rename = smb_rename, 67 .getattr = smb_getattr, 68 .setattr = smb_notify_change, 69 .symlink = smb_symlink, 70 .mknod = smb_make_node, 71 .link = smb_link, 72 }; 73 74 /* 75 * Read a directory, using filldir to fill the dirent memory. 76 * smb_proc_readdir does the actual reading from the smb server. 77 * 78 * The cache code is almost directly taken from ncpfs 79 */ 80 static int 81 smb_readdir(struct file *filp, void *dirent, filldir_t filldir) 82 { 83 struct dentry *dentry = filp->f_path.dentry; 84 struct inode *dir = dentry->d_inode; 85 struct smb_sb_info *server = server_from_dentry(dentry); 86 union smb_dir_cache *cache = NULL; 87 struct smb_cache_control ctl; 88 struct page *page = NULL; 89 int result; 90 91 ctl.page = NULL; 92 ctl.cache = NULL; 93 94 VERBOSE("reading %s/%s, f_pos=%d\n", 95 DENTRY_PATH(dentry), (int) filp->f_pos); 96 97 result = 0; 98 99 lock_kernel(); 100 101 switch ((unsigned int) filp->f_pos) { 102 case 0: 103 if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0) 104 goto out; 105 filp->f_pos = 1; 106 /* fallthrough */ 107 case 1: 108 if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0) 109 goto out; 110 filp->f_pos = 2; 111 } 112 113 /* 114 * Make sure our inode is up-to-date. 115 */ 116 result = smb_revalidate_inode(dentry); 117 if (result) 118 goto out; 119 120 121 page = grab_cache_page(&dir->i_data, 0); 122 if (!page) 123 goto read_really; 124 125 ctl.cache = cache = kmap(page); 126 ctl.head = cache->head; 127 128 if (!PageUptodate(page) || !ctl.head.eof) { 129 VERBOSE("%s/%s, page uptodate=%d, eof=%d\n", 130 DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof); 131 goto init_cache; 132 } 133 134 if (filp->f_pos == 2) { 135 if (jiffies - ctl.head.time >= SMB_MAX_AGE(server)) 136 goto init_cache; 137 138 /* 139 * N.B. ncpfs checks mtime of dentry too here, we don't. 140 * 1. common smb servers do not update mtime on dir changes 141 * 2. it requires an extra smb request 142 * (revalidate has the same timeout as ctl.head.time) 143 * 144 * Instead smbfs invalidates its own cache on local changes 145 * and remote changes are not seen until timeout. 146 */ 147 } 148 149 if (filp->f_pos > ctl.head.end) 150 goto finished; 151 152 ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2); 153 ctl.ofs = ctl.fpos / SMB_DIRCACHE_SIZE; 154 ctl.idx = ctl.fpos % SMB_DIRCACHE_SIZE; 155 156 for (;;) { 157 if (ctl.ofs != 0) { 158 ctl.page = find_lock_page(&dir->i_data, ctl.ofs); 159 if (!ctl.page) 160 goto invalid_cache; 161 ctl.cache = kmap(ctl.page); 162 if (!PageUptodate(ctl.page)) 163 goto invalid_cache; 164 } 165 while (ctl.idx < SMB_DIRCACHE_SIZE) { 166 struct dentry *dent; 167 int res; 168 169 dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx], 170 dentry, filp->f_pos); 171 if (!dent) 172 goto invalid_cache; 173 174 res = filldir(dirent, dent->d_name.name, 175 dent->d_name.len, filp->f_pos, 176 dent->d_inode->i_ino, DT_UNKNOWN); 177 dput(dent); 178 if (res) 179 goto finished; 180 filp->f_pos += 1; 181 ctl.idx += 1; 182 if (filp->f_pos > ctl.head.end) 183 goto finished; 184 } 185 if (ctl.page) { 186 kunmap(ctl.page); 187 SetPageUptodate(ctl.page); 188 unlock_page(ctl.page); 189 page_cache_release(ctl.page); 190 ctl.page = NULL; 191 } 192 ctl.idx = 0; 193 ctl.ofs += 1; 194 } 195 invalid_cache: 196 if (ctl.page) { 197 kunmap(ctl.page); 198 unlock_page(ctl.page); 199 page_cache_release(ctl.page); 200 ctl.page = NULL; 201 } 202 ctl.cache = cache; 203 init_cache: 204 smb_invalidate_dircache_entries(dentry); 205 ctl.head.time = jiffies; 206 ctl.head.eof = 0; 207 ctl.fpos = 2; 208 ctl.ofs = 0; 209 ctl.idx = SMB_DIRCACHE_START; 210 ctl.filled = 0; 211 ctl.valid = 1; 212 read_really: 213 result = server->ops->readdir(filp, dirent, filldir, &ctl); 214 if (result == -ERESTARTSYS && page) 215 ClearPageUptodate(page); 216 if (ctl.idx == -1) 217 goto invalid_cache; /* retry */ 218 ctl.head.end = ctl.fpos - 1; 219 ctl.head.eof = ctl.valid; 220 finished: 221 if (page) { 222 cache->head = ctl.head; 223 kunmap(page); 224 if (result != -ERESTARTSYS) 225 SetPageUptodate(page); 226 unlock_page(page); 227 page_cache_release(page); 228 } 229 if (ctl.page) { 230 kunmap(ctl.page); 231 SetPageUptodate(ctl.page); 232 unlock_page(ctl.page); 233 page_cache_release(ctl.page); 234 } 235 out: 236 unlock_kernel(); 237 return result; 238 } 239 240 static int 241 smb_dir_open(struct inode *dir, struct file *file) 242 { 243 struct dentry *dentry = file->f_path.dentry; 244 struct smb_sb_info *server; 245 int error = 0; 246 247 VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name, 248 file->f_path.dentry->d_name.name); 249 250 /* 251 * Directory timestamps in the core protocol aren't updated 252 * when a file is added, so we give them a very short TTL. 253 */ 254 lock_kernel(); 255 server = server_from_dentry(dentry); 256 if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) { 257 unsigned long age = jiffies - SMB_I(dir)->oldmtime; 258 if (age > 2*HZ) 259 smb_invalid_dir_cache(dir); 260 } 261 262 /* 263 * Note: in order to allow the smbmount process to open the 264 * mount point, we only revalidate if the connection is valid or 265 * if the process is trying to access something other than the root. 266 */ 267 if (server->state == CONN_VALID || !IS_ROOT(dentry)) 268 error = smb_revalidate_inode(dentry); 269 unlock_kernel(); 270 return error; 271 } 272 273 /* 274 * Dentry operations routines 275 */ 276 static int smb_lookup_validate(struct dentry *, struct nameidata *); 277 static int smb_hash_dentry(struct dentry *, struct qstr *); 278 static int smb_compare_dentry(struct dentry *, struct qstr *, struct qstr *); 279 static int smb_delete_dentry(struct dentry *); 280 281 static const struct dentry_operations smbfs_dentry_operations = 282 { 283 .d_revalidate = smb_lookup_validate, 284 .d_hash = smb_hash_dentry, 285 .d_compare = smb_compare_dentry, 286 .d_delete = smb_delete_dentry, 287 }; 288 289 static const struct dentry_operations smbfs_dentry_operations_case = 290 { 291 .d_revalidate = smb_lookup_validate, 292 .d_delete = smb_delete_dentry, 293 }; 294 295 296 /* 297 * This is the callback when the dcache has a lookup hit. 298 */ 299 static int 300 smb_lookup_validate(struct dentry * dentry, struct nameidata *nd) 301 { 302 struct smb_sb_info *server = server_from_dentry(dentry); 303 struct inode * inode = dentry->d_inode; 304 unsigned long age = jiffies - dentry->d_time; 305 int valid; 306 307 /* 308 * The default validation is based on dentry age: 309 * we believe in dentries for a few seconds. (But each 310 * successful server lookup renews the timestamp.) 311 */ 312 valid = (age <= SMB_MAX_AGE(server)); 313 #ifdef SMBFS_DEBUG_VERBOSE 314 if (!valid) 315 VERBOSE("%s/%s not valid, age=%lu\n", 316 DENTRY_PATH(dentry), age); 317 #endif 318 319 if (inode) { 320 lock_kernel(); 321 if (is_bad_inode(inode)) { 322 PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry)); 323 valid = 0; 324 } else if (!valid) 325 valid = (smb_revalidate_inode(dentry) == 0); 326 unlock_kernel(); 327 } else { 328 /* 329 * What should we do for negative dentries? 330 */ 331 } 332 return valid; 333 } 334 335 static int 336 smb_hash_dentry(struct dentry *dir, struct qstr *this) 337 { 338 unsigned long hash; 339 int i; 340 341 hash = init_name_hash(); 342 for (i=0; i < this->len ; i++) 343 hash = partial_name_hash(tolower(this->name[i]), hash); 344 this->hash = end_name_hash(hash); 345 346 return 0; 347 } 348 349 static int 350 smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b) 351 { 352 int i, result = 1; 353 354 if (a->len != b->len) 355 goto out; 356 for (i=0; i < a->len; i++) { 357 if (tolower(a->name[i]) != tolower(b->name[i])) 358 goto out; 359 } 360 result = 0; 361 out: 362 return result; 363 } 364 365 /* 366 * This is the callback from dput() when d_count is going to 0. 367 * We use this to unhash dentries with bad inodes. 368 */ 369 static int 370 smb_delete_dentry(struct dentry * dentry) 371 { 372 if (dentry->d_inode) { 373 if (is_bad_inode(dentry->d_inode)) { 374 PARANOIA("bad inode, unhashing %s/%s\n", 375 DENTRY_PATH(dentry)); 376 return 1; 377 } 378 } else { 379 /* N.B. Unhash negative dentries? */ 380 } 381 return 0; 382 } 383 384 /* 385 * Initialize a new dentry 386 */ 387 void 388 smb_new_dentry(struct dentry *dentry) 389 { 390 struct smb_sb_info *server = server_from_dentry(dentry); 391 392 if (server->mnt->flags & SMB_MOUNT_CASE) 393 dentry->d_op = &smbfs_dentry_operations_case; 394 else 395 dentry->d_op = &smbfs_dentry_operations; 396 dentry->d_time = jiffies; 397 } 398 399 400 /* 401 * Whenever a lookup succeeds, we know the parent directories 402 * are all valid, so we want to update the dentry timestamps. 403 * N.B. Move this to dcache? 404 */ 405 void 406 smb_renew_times(struct dentry * dentry) 407 { 408 dget(dentry); 409 spin_lock(&dentry->d_lock); 410 for (;;) { 411 struct dentry *parent; 412 413 dentry->d_time = jiffies; 414 if (IS_ROOT(dentry)) 415 break; 416 parent = dentry->d_parent; 417 dget(parent); 418 spin_unlock(&dentry->d_lock); 419 dput(dentry); 420 dentry = parent; 421 spin_lock(&dentry->d_lock); 422 } 423 spin_unlock(&dentry->d_lock); 424 dput(dentry); 425 } 426 427 static struct dentry * 428 smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 429 { 430 struct smb_fattr finfo; 431 struct inode *inode; 432 int error; 433 struct smb_sb_info *server; 434 435 error = -ENAMETOOLONG; 436 if (dentry->d_name.len > SMB_MAXNAMELEN) 437 goto out; 438 439 /* Do not allow lookup of names with backslashes in */ 440 error = -EINVAL; 441 if (memchr(dentry->d_name.name, '\\', dentry->d_name.len)) 442 goto out; 443 444 lock_kernel(); 445 error = smb_proc_getattr(dentry, &finfo); 446 #ifdef SMBFS_PARANOIA 447 if (error && error != -ENOENT) 448 PARANOIA("find %s/%s failed, error=%d\n", 449 DENTRY_PATH(dentry), error); 450 #endif 451 452 inode = NULL; 453 if (error == -ENOENT) 454 goto add_entry; 455 if (!error) { 456 error = -EACCES; 457 finfo.f_ino = iunique(dentry->d_sb, 2); 458 inode = smb_iget(dir->i_sb, &finfo); 459 if (inode) { 460 add_entry: 461 server = server_from_dentry(dentry); 462 if (server->mnt->flags & SMB_MOUNT_CASE) 463 dentry->d_op = &smbfs_dentry_operations_case; 464 else 465 dentry->d_op = &smbfs_dentry_operations; 466 467 d_add(dentry, inode); 468 smb_renew_times(dentry); 469 error = 0; 470 } 471 } 472 unlock_kernel(); 473 out: 474 return ERR_PTR(error); 475 } 476 477 /* 478 * This code is common to all routines creating a new inode. 479 */ 480 static int 481 smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id) 482 { 483 struct smb_sb_info *server = server_from_dentry(dentry); 484 struct inode *inode; 485 int error; 486 struct smb_fattr fattr; 487 488 VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid); 489 490 error = smb_proc_getattr(dentry, &fattr); 491 if (error) 492 goto out_close; 493 494 smb_renew_times(dentry); 495 fattr.f_ino = iunique(dentry->d_sb, 2); 496 inode = smb_iget(dentry->d_sb, &fattr); 497 if (!inode) 498 goto out_no_inode; 499 500 if (have_id) { 501 struct smb_inode_info *ei = SMB_I(inode); 502 ei->fileid = fileid; 503 ei->access = SMB_O_RDWR; 504 ei->open = server->generation; 505 } 506 d_instantiate(dentry, inode); 507 out: 508 return error; 509 510 out_no_inode: 511 error = -EACCES; 512 out_close: 513 if (have_id) { 514 PARANOIA("%s/%s failed, error=%d, closing %u\n", 515 DENTRY_PATH(dentry), error, fileid); 516 smb_close_fileid(dentry, fileid); 517 } 518 goto out; 519 } 520 521 /* N.B. How should the mode argument be used? */ 522 static int 523 smb_create(struct inode *dir, struct dentry *dentry, int mode, 524 struct nameidata *nd) 525 { 526 struct smb_sb_info *server = server_from_dentry(dentry); 527 __u16 fileid; 528 int error; 529 struct iattr attr; 530 531 VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode); 532 533 lock_kernel(); 534 smb_invalid_dir_cache(dir); 535 error = smb_proc_create(dentry, 0, get_seconds(), &fileid); 536 if (!error) { 537 if (server->opt.capabilities & SMB_CAP_UNIX) { 538 /* Set attributes for new file */ 539 attr.ia_valid = ATTR_MODE; 540 attr.ia_mode = mode; 541 error = smb_proc_setattr_unix(dentry, &attr, 0, 0); 542 } 543 error = smb_instantiate(dentry, fileid, 1); 544 } else { 545 PARANOIA("%s/%s failed, error=%d\n", 546 DENTRY_PATH(dentry), error); 547 } 548 unlock_kernel(); 549 return error; 550 } 551 552 /* N.B. How should the mode argument be used? */ 553 static int 554 smb_mkdir(struct inode *dir, struct dentry *dentry, int mode) 555 { 556 struct smb_sb_info *server = server_from_dentry(dentry); 557 int error; 558 struct iattr attr; 559 560 lock_kernel(); 561 smb_invalid_dir_cache(dir); 562 error = smb_proc_mkdir(dentry); 563 if (!error) { 564 if (server->opt.capabilities & SMB_CAP_UNIX) { 565 /* Set attributes for new directory */ 566 attr.ia_valid = ATTR_MODE; 567 attr.ia_mode = mode; 568 error = smb_proc_setattr_unix(dentry, &attr, 0, 0); 569 } 570 error = smb_instantiate(dentry, 0, 0); 571 } 572 unlock_kernel(); 573 return error; 574 } 575 576 static int 577 smb_rmdir(struct inode *dir, struct dentry *dentry) 578 { 579 struct inode *inode = dentry->d_inode; 580 int error; 581 582 /* 583 * Close the directory if it's open. 584 */ 585 lock_kernel(); 586 smb_close(inode); 587 588 /* 589 * Check that nobody else is using the directory.. 590 */ 591 error = -EBUSY; 592 if (!d_unhashed(dentry)) 593 goto out; 594 595 smb_invalid_dir_cache(dir); 596 error = smb_proc_rmdir(dentry); 597 598 out: 599 unlock_kernel(); 600 return error; 601 } 602 603 static int 604 smb_unlink(struct inode *dir, struct dentry *dentry) 605 { 606 int error; 607 608 /* 609 * Close the file if it's open. 610 */ 611 lock_kernel(); 612 smb_close(dentry->d_inode); 613 614 smb_invalid_dir_cache(dir); 615 error = smb_proc_unlink(dentry); 616 if (!error) 617 smb_renew_times(dentry); 618 unlock_kernel(); 619 return error; 620 } 621 622 static int 623 smb_rename(struct inode *old_dir, struct dentry *old_dentry, 624 struct inode *new_dir, struct dentry *new_dentry) 625 { 626 int error; 627 628 /* 629 * Close any open files, and check whether to delete the 630 * target before attempting the rename. 631 */ 632 lock_kernel(); 633 if (old_dentry->d_inode) 634 smb_close(old_dentry->d_inode); 635 if (new_dentry->d_inode) { 636 smb_close(new_dentry->d_inode); 637 error = smb_proc_unlink(new_dentry); 638 if (error) { 639 VERBOSE("unlink %s/%s, error=%d\n", 640 DENTRY_PATH(new_dentry), error); 641 goto out; 642 } 643 /* FIXME */ 644 d_delete(new_dentry); 645 } 646 647 smb_invalid_dir_cache(old_dir); 648 smb_invalid_dir_cache(new_dir); 649 error = smb_proc_mv(old_dentry, new_dentry); 650 if (!error) { 651 smb_renew_times(old_dentry); 652 smb_renew_times(new_dentry); 653 } 654 out: 655 unlock_kernel(); 656 return error; 657 } 658 659 /* 660 * FIXME: samba servers won't let you create device nodes unless uid/gid 661 * matches the connection credentials (and we don't know which those are ...) 662 */ 663 static int 664 smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) 665 { 666 int error; 667 struct iattr attr; 668 669 attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID; 670 attr.ia_mode = mode; 671 current_euid_egid(&attr.ia_uid, &attr.ia_gid); 672 673 if (!new_valid_dev(dev)) 674 return -EINVAL; 675 676 smb_invalid_dir_cache(dir); 677 error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev)); 678 if (!error) { 679 error = smb_instantiate(dentry, 0, 0); 680 } 681 return error; 682 } 683 684 /* 685 * dentry = existing file 686 * new_dentry = new file 687 */ 688 static int 689 smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry) 690 { 691 int error; 692 693 DEBUG1("smb_link old=%s/%s new=%s/%s\n", 694 DENTRY_PATH(dentry), DENTRY_PATH(new_dentry)); 695 smb_invalid_dir_cache(dir); 696 error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry); 697 if (!error) { 698 smb_renew_times(dentry); 699 error = smb_instantiate(new_dentry, 0, 0); 700 } 701 return error; 702 }
Cache object: 6148fcf01d599c9d3d879d9907a602f7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]