fs/coda/dir.c

   1
   2 /*
   3  * Directory operations for Coda filesystem
   4  * Original version: (C) 1996 P. Braam and M. Callahan
   5  * Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University
   6  *
   7  * Carnegie Mellon encourages users to contribute improvements to
   8  * the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
   9  */
  10
  11 #include <linux/types.h>
  12 #include <linux/kernel.h>
  13 #include <linux/time.h>
  14 #include <linux/fs.h>
  15 #include <linux/slab.h>
  16 #include <linux/file.h>
  17 #include <linux/stat.h>
  18 #include <linux/errno.h>
  19 #include <linux/string.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/namei.h>
  22
  23 #include <asm/uaccess.h>
  24
  25 #include <linux/coda.h>
  26 #include <linux/coda_linux.h>
  27 #include <linux/coda_psdev.h>
  28 #include <linux/coda_fs_i.h>
  29 #include <linux/coda_cache.h>
  30
  31 #include "coda_int.h"
  32
  33 /* dir inode-ops */
  34 static int coda_create(struct inode *dir, struct dentry *new, int mode, struct nameidata *nd);
  35 static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd);
  36 static int coda_link(struct dentry *old_dentry, struct inode *dir_inode,
  37                      struct dentry *entry);
  38 static int coda_unlink(struct inode *dir_inode, struct dentry *entry);
  39 static int coda_symlink(struct inode *dir_inode, struct dentry *entry,
  40                         const char *symname);
  41 static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, int mode);
  42 static int coda_rmdir(struct inode *dir_inode, struct dentry *entry);
  43 static int coda_rename(struct inode *old_inode, struct dentry *old_dentry,
  44                        struct inode *new_inode, struct dentry *new_dentry);
  45
  46 /* dir file-ops */
  47 static int coda_readdir(struct file *file, void *buf, filldir_t filldir);
  48
  49 /* dentry ops */
  50 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd);
  51 static int coda_dentry_delete(const struct dentry *);
  52
  53 /* support routines */
  54 static int coda_venus_readdir(struct file *coda_file, void *buf,
  55                               filldir_t filldir);
  56
  57 /* same as fs/bad_inode.c */
  58 static int coda_return_EIO(void)
  59 {
  60         return -EIO;
  61 }
  62 #define CODA_EIO_ERROR ((void *) (coda_return_EIO))
  63
  64 static const struct dentry_operations coda_dentry_operations =
  65 {
  66         .d_revalidate   = coda_dentry_revalidate,
  67         .d_delete       = coda_dentry_delete,
  68 };
  69
  70 const struct inode_operations coda_dir_inode_operations =
  71 {
  72         .create         = coda_create,
  73         .lookup         = coda_lookup,
  74         .link           = coda_link,
  75         .unlink         = coda_unlink,
  76         .symlink        = coda_symlink,
  77         .mkdir          = coda_mkdir,
  78         .rmdir          = coda_rmdir,
  79         .mknod          = CODA_EIO_ERROR,
  80         .rename         = coda_rename,
  81         .permission     = coda_permission,
  82         .getattr        = coda_getattr,
  83         .setattr        = coda_setattr,
  84 };
  85
  86 const struct file_operations coda_dir_operations = {
  87         .llseek         = generic_file_llseek,
  88         .read           = generic_read_dir,
  89         .readdir        = coda_readdir,
  90         .open           = coda_open,
  91         .release        = coda_release,
  92         .fsync          = coda_fsync,
  93 };
  94
  95
  96 /* inode operations for directories */
  97 /* access routines: lookup, readlink, permission */
  98 static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struct nameidata *nd)
  99 {
 100         struct inode *inode = NULL;
 101         struct CodaFid resfid = { { 0, } };
 102         int type = 0;
 103         int error = 0;
 104         const char *name = entry->d_name.name;
 105         size_t length = entry->d_name.len;
 106
 107         if (length > CODA_MAXNAMLEN) {
 108                 printk(KERN_ERR "name too long: lookup, %s (%*s)\n",
 109                        coda_i2s(dir), (int)length, name);
 110                 return ERR_PTR(-ENAMETOOLONG);
 111         }
 112
 113         /* control object, create inode on the fly */
 114         if (coda_isroot(dir) && coda_iscontrol(name, length)) {
 115                 error = coda_cnode_makectl(&inode, dir->i_sb);
 116                 type = CODA_NOCACHE;
 117                 goto exit;
 118         }
 119
 120         error = venus_lookup(dir->i_sb, coda_i2f(dir), name, length,
 121                              &type, &resfid);
 122         if (!error)
 123                 error = coda_cnode_make(&inode, &resfid, dir->i_sb);
 124
 125         if (error && error != -ENOENT)
 126                 return ERR_PTR(error);
 127
 128 exit:
 129         d_set_d_op(entry, &coda_dentry_operations);
 130
 131         if (inode && (type & CODA_NOCACHE))
 132                 coda_flag_inode(inode, C_VATTR | C_PURGE);
 133
 134         return d_splice_alias(inode, entry);
 135 }
 136
 137
 138 int coda_permission(struct inode *inode, int mask, unsigned int flags)
 139 {
 140         int error;
 141
 142         if (flags & IPERM_FLAG_RCU)
 143                 return -ECHILD;
 144
 145         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
 146
 147         if (!mask)
 148                 return 0;
 149
 150         if ((mask & MAY_EXEC) && !execute_ok(inode))
 151                 return -EACCES;
 152
 153         if (coda_cache_check(inode, mask))
 154                 return 0;
 155
 156         error = venus_access(inode->i_sb, coda_i2f(inode), mask);
 157
 158         if (!error)
 159                 coda_cache_enter(inode, mask);
 160
 161         return error;
 162 }
 163
 164
 165 static inline void coda_dir_update_mtime(struct inode *dir)
 166 {
 167 #ifdef REQUERY_VENUS_FOR_MTIME
 168         /* invalidate the directory cnode's attributes so we refetch the
 169          * attributes from venus next time the inode is referenced */
 170         coda_flag_inode(dir, C_VATTR);
 171 #else
 172         /* optimistically we can also act as if our nose bleeds. The
 173          * granularity of the mtime is coarse anyways so we might actually be
 174          * right most of the time. Note: we only do this for directories. */
 175         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 176 #endif
 177 }
 178
 179 /* we have to wrap inc_nlink/drop_nlink because sometimes userspace uses a
 180  * trick to fool GNU find's optimizations. If we can't be sure of the link
 181  * (because of volume mount points) we set i_nlink to 1 which forces find
 182  * to consider every child as a possible directory. We should also never
 183  * see an increment or decrement for deleted directories where i_nlink == 0 */
 184 static inline void coda_dir_inc_nlink(struct inode *dir)
 185 {
 186         if (dir->i_nlink >= 2)
 187                 inc_nlink(dir);
 188 }
 189
 190 static inline void coda_dir_drop_nlink(struct inode *dir)
 191 {
 192         if (dir->i_nlink > 2)
 193                 drop_nlink(dir);
 194 }
 195
 196 /* creation routines: create, mknod, mkdir, link, symlink */
 197 static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd)
 198 {
 199         int error;
 200         const char *name=de->d_name.name;
 201         int length=de->d_name.len;
 202         struct inode *inode;
 203         struct CodaFid newfid;
 204         struct coda_vattr attrs;
 205
 206         if (coda_isroot(dir) && coda_iscontrol(name, length))
 207                 return -EPERM;
 208
 209         error = venus_create(dir->i_sb, coda_i2f(dir), name, length,
 210                                 0, mode, &newfid, &attrs);
 211         if (error)
 212                 goto err_out;
 213
 214         inode = coda_iget(dir->i_sb, &newfid, &attrs);
 215         if (IS_ERR(inode)) {
 216                 error = PTR_ERR(inode);
 217                 goto err_out;
 218         }
 219
 220         /* invalidate the directory cnode's attributes */
 221         coda_dir_update_mtime(dir);
 222         d_instantiate(de, inode);
 223         return 0;
 224 err_out:
 225         d_drop(de);
 226         return error;
 227 }
 228
 229 static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
 230 {
 231         struct inode *inode;
 232         struct coda_vattr attrs;
 233         const char *name = de->d_name.name;
 234         int len = de->d_name.len;
 235         int error;
 236         struct CodaFid newfid;
 237
 238         if (coda_isroot(dir) && coda_iscontrol(name, len))
 239                 return -EPERM;
 240
 241         attrs.va_mode = mode;
 242         error = venus_mkdir(dir->i_sb, coda_i2f(dir),
 243                                name, len, &newfid, &attrs);
 244         if (error)
 245                 goto err_out;
 246
 247         inode = coda_iget(dir->i_sb, &newfid, &attrs);
 248         if (IS_ERR(inode)) {
 249                 error = PTR_ERR(inode);
 250                 goto err_out;
 251         }
 252
 253         /* invalidate the directory cnode's attributes */
 254         coda_dir_inc_nlink(dir);
 255         coda_dir_update_mtime(dir);
 256         d_instantiate(de, inode);
 257         return 0;
 258 err_out:
 259         d_drop(de);
 260         return error;
 261 }
 262
 263 /* try to make de an entry in dir_inodde linked to source_de */
 264 static int coda_link(struct dentry *source_de, struct inode *dir_inode,
 265           struct dentry *de)
 266 {
 267         struct inode *inode = source_de->d_inode;
 268         const char * name = de->d_name.name;
 269         int len = de->d_name.len;
 270         int error;
 271
 272         if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
 273                 return -EPERM;
 274
 275         error = venus_link(dir_inode->i_sb, coda_i2f(inode),
 276                            coda_i2f(dir_inode), (const char *)name, len);
 277         if (error) {
 278                 d_drop(de);
 279                 return error;
 280         }
 281
 282         coda_dir_update_mtime(dir_inode);
 283         ihold(inode);
 284         d_instantiate(de, inode);
 285         inc_nlink(inode);
 286         return 0;
 287 }
 288
 289
 290 static int coda_symlink(struct inode *dir_inode, struct dentry *de,
 291                         const char *symname)
 292 {
 293         const char *name = de->d_name.name;
 294         int len = de->d_name.len;
 295         int symlen;
 296         int error;
 297
 298         if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
 299                 return -EPERM;
 300
 301         symlen = strlen(symname);
 302         if (symlen > CODA_MAXPATHLEN)
 303                 return -ENAMETOOLONG;
 304
 305         /*
 306          * This entry is now negative. Since we do not create
 307          * an inode for the entry we have to drop it.
 308          */
 309         d_drop(de);
 310         error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
 311                               symname, symlen);
 312
 313         /* mtime is no good anymore */
 314         if (!error)
 315                 coda_dir_update_mtime(dir_inode);
 316
 317         return error;
 318 }
 319
 320 /* destruction routines: unlink, rmdir */
 321 static int coda_unlink(struct inode *dir, struct dentry *de)
 322 {
 323         int error;
 324         const char *name = de->d_name.name;
 325         int len = de->d_name.len;
 326
 327         error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);
 328         if (error)
 329                 return error;
 330
 331         coda_dir_update_mtime(dir);
 332         drop_nlink(de->d_inode);
 333         return 0;
 334 }
 335
 336 static int coda_rmdir(struct inode *dir, struct dentry *de)
 337 {
 338         const char *name = de->d_name.name;
 339         int len = de->d_name.len;
 340         int error;
 341
 342         error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
 343         if (!error) {
 344                 /* VFS may delete the child */
 345                 if (de->d_inode)
 346                     de->d_inode->i_nlink = 0;
 347
 348                 /* fix the link count of the parent */
 349                 coda_dir_drop_nlink(dir);
 350                 coda_dir_update_mtime(dir);
 351         }
 352         return error;
 353 }
 354
 355 /* rename */
 356 static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
 357                        struct inode *new_dir, struct dentry *new_dentry)
 358 {
 359         const char *old_name = old_dentry->d_name.name;
 360         const char *new_name = new_dentry->d_name.name;
 361         int old_length = old_dentry->d_name.len;
 362         int new_length = new_dentry->d_name.len;
 363         int error;
 364
 365         error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
 366                              coda_i2f(new_dir), old_length, new_length,
 367                              (const char *) old_name, (const char *)new_name);
 368         if (!error) {
 369                 if (new_dentry->d_inode) {
 370                         if (S_ISDIR(new_dentry->d_inode->i_mode)) {
 371                                 coda_dir_drop_nlink(old_dir);
 372                                 coda_dir_inc_nlink(new_dir);
 373                         }
 374                         coda_dir_update_mtime(old_dir);
 375                         coda_dir_update_mtime(new_dir);
 376                         coda_flag_inode(new_dentry->d_inode, C_VATTR);
 377                 } else {
 378                         coda_flag_inode(old_dir, C_VATTR);
 379                         coda_flag_inode(new_dir, C_VATTR);
 380                 }
 381         }
 382         return error;
 383 }
 384
 385
 386 /* file operations for directories */
 387 static int coda_readdir(struct file *coda_file, void *buf, filldir_t filldir)
 388 {
 389         struct coda_file_info *cfi;
 390         struct file *host_file;
 391         int ret;
 392
 393         cfi = CODA_FTOC(coda_file);
 394         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
 395         host_file = cfi->cfi_container;
 396
 397         if (!host_file->f_op)
 398                 return -ENOTDIR;
 399
 400         if (host_file->f_op->readdir)
 401         {
 402                 /* potemkin case: we were handed a directory inode.
 403                  * We can't use vfs_readdir because we have to keep the file
 404                  * position in sync between the coda_file and the host_file.
 405                  * and as such we need grab the inode mutex. */
 406                 struct inode *host_inode = host_file->f_path.dentry->d_inode;
 407
 408                 mutex_lock(&host_inode->i_mutex);
 409                 host_file->f_pos = coda_file->f_pos;
 410
 411                 ret = -ENOENT;
 412                 if (!IS_DEADDIR(host_inode)) {
 413                         ret = host_file->f_op->readdir(host_file, buf, filldir);
 414                         file_accessed(host_file);
 415                 }
 416
 417                 coda_file->f_pos = host_file->f_pos;
 418                 mutex_unlock(&host_inode->i_mutex);
 419         }
 420         else /* Venus: we must read Venus dirents from a file */
 421                 ret = coda_venus_readdir(coda_file, buf, filldir);
 422
 423         return ret;
 424 }
 425
 426 static inline unsigned int CDT2DT(unsigned char cdt)
 427 {
 428         unsigned int dt;
 429
 430         switch(cdt) {
 431         case CDT_UNKNOWN: dt = DT_UNKNOWN; break;
 432         case CDT_FIFO:    dt = DT_FIFO;    break;
 433         case CDT_CHR:     dt = DT_CHR;     break;
 434         case CDT_DIR:     dt = DT_DIR;     break;
 435         case CDT_BLK:     dt = DT_BLK;     break;
 436         case CDT_REG:     dt = DT_REG;     break;
 437         case CDT_LNK:     dt = DT_LNK;     break;
 438         case CDT_SOCK:    dt = DT_SOCK;    break;
 439         case CDT_WHT:     dt = DT_WHT;     break;
 440         default:          dt = DT_UNKNOWN; break;
 441         }
 442         return dt;
 443 }
 444
 445 /* support routines */
 446 static int coda_venus_readdir(struct file *coda_file, void *buf,
 447                               filldir_t filldir)
 448 {
 449         int result = 0; /* # of entries returned */
 450         struct coda_file_info *cfi;
 451         struct coda_inode_info *cii;
 452         struct file *host_file;
 453         struct dentry *de;
 454         struct venus_dirent *vdir;
 455         unsigned long vdir_size =
 456             (unsigned long)(&((struct venus_dirent *)0)->d_name);
 457         unsigned int type;
 458         struct qstr name;
 459         ino_t ino;
 460         int ret;
 461
 462         cfi = CODA_FTOC(coda_file);
 463         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
 464         host_file = cfi->cfi_container;
 465
 466         de = coda_file->f_path.dentry;
 467         cii = ITOC(de->d_inode);
 468
 469         vdir = kmalloc(sizeof(*vdir), GFP_KERNEL);
 470         if (!vdir) return -ENOMEM;
 471
 472         if (coda_file->f_pos == 0) {
 473                 ret = filldir(buf, ".", 1, 0, de->d_inode->i_ino, DT_DIR);
 474                 if (ret < 0)
 475                         goto out;
 476                 result++;
 477                 coda_file->f_pos++;
 478         }
 479         if (coda_file->f_pos == 1) {
 480                 ret = filldir(buf, "..", 2, 1, de->d_parent->d_inode->i_ino, DT_DIR);
 481                 if (ret < 0)
 482                         goto out;
 483                 result++;
 484                 coda_file->f_pos++;
 485         }
 486         while (1) {
 487                 /* read entries from the directory file */
 488                 ret = kernel_read(host_file, coda_file->f_pos - 2, (char *)vdir,
 489                                   sizeof(*vdir));
 490                 if (ret < 0) {
 491                         printk(KERN_ERR "coda readdir: read dir %s failed %d\n",
 492                                coda_f2s(&cii->c_fid), ret);
 493                         break;
 494                 }
 495                 if (ret == 0) break; /* end of directory file reached */
 496
 497                 /* catch truncated reads */
 498                 if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
 499                         printk(KERN_ERR "coda readdir: short read on %s\n",
 500                                coda_f2s(&cii->c_fid));
 501                         ret = -EBADF;
 502                         break;
 503                 }
 504                 /* validate whether the directory file actually makes sense */
 505                 if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
 506                         printk(KERN_ERR "coda readdir: invalid dir %s\n",
 507                                coda_f2s(&cii->c_fid));
 508                         ret = -EBADF;
 509                         break;
 510                 }
 511
 512                 name.len = vdir->d_namlen;
 513                 name.name = vdir->d_name;
 514
 515                 /* Make sure we skip '.' and '..', we already got those */
 516                 if (name.name[0] == '.' && (name.len == 1 ||
 517                     (vdir->d_name[1] == '.' && name.len == 2)))
 518                         vdir->d_fileno = name.len = 0;
 519
 520                 /* skip null entries */
 521                 if (vdir->d_fileno && name.len) {
 522                         /* try to look up this entry in the dcache, that way
 523                          * userspace doesn't have to worry about breaking
 524                          * getcwd by having mismatched inode numbers for
 525                          * internal volume mountpoints. */
 526                         ino = find_inode_number(de, &name);
 527                         if (!ino) ino = vdir->d_fileno;
 528
 529                         type = CDT2DT(vdir->d_type);
 530                         ret = filldir(buf, name.name, name.len,
 531                                       coda_file->f_pos, ino, type);
 532                         /* failure means no space for filling in this round */
 533                         if (ret < 0) break;
 534                         result++;
 535                 }
 536                 /* we'll always have progress because d_reclen is unsigned and
 537                  * we've already established it is non-zero. */
 538                 coda_file->f_pos += vdir->d_reclen;
 539         }
 540 out:
 541         kfree(vdir);
 542         return result ? result : ret;
 543 }
 544
 545 /* called when a cache lookup succeeds */
 546 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd)
 547 {
 548         struct inode *inode;
 549         struct coda_inode_info *cii;
 550
 551         if (nd->flags & LOOKUP_RCU)
 552                 return -ECHILD;
 553
 554         inode = de->d_inode;
 555         if (!inode || coda_isroot(inode))
 556                 goto out;
 557         if (is_bad_inode(inode))
 558                 goto bad;
 559
 560         cii = ITOC(de->d_inode);
 561         if (!(cii->c_flags & (C_PURGE | C_FLUSH)))
 562                 goto out;
 563
 564         shrink_dcache_parent(de);
 565
 566         /* propagate for a flush */
 567         if (cii->c_flags & C_FLUSH)
 568                 coda_flag_inode_children(inode, C_FLUSH);
 569
 570         if (de->d_count > 1)
 571                 /* pretend it's valid, but don't change the flags */
 572                 goto out;
 573
 574         /* clear the flags. */
 575         spin_lock(&cii->c_lock);
 576         cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
 577         spin_unlock(&cii->c_lock);
 578 bad:
 579         return 0;
 580 out:
 581         return 1;
 582 }
 583
 584 /*
 585  * This is the callback from dput() when d_count is going to 0.
 586  * We use this to unhash dentries with bad inodes.
 587  */
 588 static int coda_dentry_delete(const struct dentry * dentry)
 589 {
 590         int flags;
 591
 592         if (!dentry->d_inode)
 593                 return 0;
 594
 595         flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE;
 596         if (is_bad_inode(dentry->d_inode) || flags) {
 597                 return 1;
 598         }
 599         return 0;
 600 }
 601
 602
 603
 604 /*
 605  * This is called when we want to check if the inode has
 606  * changed on the server.  Coda makes this easy since the
 607  * cache manager Venus issues a downcall to the kernel when this
 608  * happens
 609  */
 610 int coda_revalidate_inode(struct dentry *dentry)
 611 {
 612         struct coda_vattr attr;
 613         int error;
 614         int old_mode;
 615         ino_t old_ino;
 616         struct inode *inode = dentry->d_inode;
 617         struct coda_inode_info *cii = ITOC(inode);
 618
 619         if (!cii->c_flags)
 620                 return 0;
 621
 622         if (cii->c_flags & (C_VATTR | C_PURGE | C_FLUSH)) {
 623                 error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr);
 624                 if (error)
 625                         return -EIO;
 626
 627                 /* this inode may be lost if:
 628                    - it's ino changed
 629                    - type changes must be permitted for repair and
 630                    missing mount points.
 631                 */
 632                 old_mode = inode->i_mode;
 633                 old_ino = inode->i_ino;
 634                 coda_vattr_to_iattr(inode, &attr);
 635
 636                 if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
 637                         printk("Coda: inode %ld, fid %s changed type!\n",
 638                                inode->i_ino, coda_f2s(&(cii->c_fid)));
 639                 }
 640
 641                 /* the following can happen when a local fid is replaced
 642                    with a global one, here we lose and declare the inode bad */
 643                 if (inode->i_ino != old_ino)
 644                         return -EIO;
 645
 646                 coda_flag_inode_children(inode, C_FLUSH);
 647
 648                 spin_lock(&cii->c_lock);
 649                 cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
 650                 spin_unlock(&cii->c_lock);
 651         }
 652         return 0;
 653 }