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