fs/smbfs/dir.c

   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 }