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 } 654