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 */ 33static int coda_create(struct inode *dir, struct dentry *new, int mode, struct nameidata *nd); 34static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd); 35static int coda_link(struct dentry *old_dentry, struct inode *dir_inode, 36 struct dentry *entry); 37static int coda_unlink(struct inode *dir_inode, struct dentry *entry); 38static int coda_symlink(struct inode *dir_inode, struct dentry *entry, 39 const char *symname); 40static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, int mode); 41static int coda_rmdir(struct inode *dir_inode, struct dentry *entry); 42static 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 */ 46static int coda_readdir(struct file *file, void *dirent, filldir_t filldir); 47 48/* dentry ops */ 49static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd); 50static int coda_dentry_delete(struct dentry *); 51 52/* support routines */ 53static int coda_venus_readdir(struct file *filp, filldir_t filldir, 54 void *dirent, struct dentry *dir); 55 56/* same as fs/bad_inode.c */ 57static int coda_return_EIO(void) 58{ 59 return -EIO; 60} 61#define CODA_EIO_ERROR ((void *) (coda_return_EIO)) 62 63static struct dentry_operations coda_dentry_operations = 64{ 65 .d_revalidate = coda_dentry_revalidate, 66 .d_delete = coda_dentry_delete, 67}; 68 69const 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 85const 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 */ 98static 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 142exit: 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 155int 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 181static 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 */ 198static 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 238static 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 */ 280static 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 309out: 310 unlock_kernel(); 311 return(error); 312} 313 314 315static 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 */ 354int 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 376int 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 */ 405static 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 */ 442int 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 } 477out: 478 coda_file->f_pos = host_file->f_pos; 479 mutex_unlock(&host_inode->i_mutex); 480 481 return ret; 482} 483 484static 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 */ 504static 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 */ 593static 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 623bad: 624 unlock_kernel(); 625 return 0; 626out: 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 */ 635static 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 */ 657int 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 698ok: 699 unlock_kernel(); 700 return 0; 701 702return_bad: 703 unlock_kernel(); 704 return -EIO; 705} 706