lustre/obdfs/namei.c

   1 /*
   2  *  linux/fs/ext2/namei.c
   3  *
   4  * Copyright (C) 1992, 1993, 1994, 1995
   5  * Remy Card (card@masi.ibp.fr)
   6  * Laboratoire MASI - Institut Blaise Pascal
   7  * Universite Pierre et Marie Curie (Paris VI)
   8  *
   9  *  from
  10  *
  11  *  linux/fs/minix/namei.c
  12  *
  13  *  Copyright (C) 1991, 1992  Linus Torvalds
  14  *
  15  *  Big-endian to little-endian byte-swapping/bitmaps by
  16  *        David S. Miller (davem@caip.rutgers.edu), 1995
  17  *  Directory entry file type support and forward compatibility hooks
  18  *      for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
  19  *
  20  *  Changes for use in OBDFS
  21  *  Copyright (c) 1999, Seagate Technology Inc.
  22  *
  23  */
  24
  25 #include <asm/uaccess.h>
  26
  27 #include <linux/errno.h>
  28 #include <linux/fs.h>
  29 #include <linux/ext2_fs.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/sched.h>
  32 #include <linux/stat.h>
  33 #include <linux/string.h>
  34 #include <linux/locks.h>
  35 #include <linux/quotaops.h>
  36 #include <linux/iobuf.h>
  37
  38 #include <linux/obd_support.h>
  39 #include "obdfs.h"
  40
  41 /*
  42  * define how far ahead to read directories while searching them.
  43  */
  44 #define NAMEI_RA_CHUNKS  2
  45 #define NAMEI_RA_BLOCKS  4
  46 #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
  47 #define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
  48
  49 /*
  50  * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
  51  *
  52  * `len <= EXT2_NAME_LEN' is guaranteed by caller.
  53  * `de != NULL' is guaranteed by caller.
  54  */
  55 static inline int ext2_match (int len, const char * const name,
  56                        struct ext2_dir_entry_2 * de)
  57 {
  58         if (len != de->name_len)
  59                 return 0;
  60         if (!de->inode)
  61                 return 0;
  62         return !memcmp(name, de->name, len);
  63 }
  64
  65 /*
  66  *      ext2_find_entry()
  67  *
  68  * finds an entry in the specified directory with the wanted name. It
  69  * returns the cache buffer in which the entry was found, and the entry
  70  * itself (as a parameter - res_dir). It does NOT read the inode of the
  71  * entry - you'll have to do that yourself if you want to.
  72  */
  73 struct page * obdfs_find_entry (struct inode * dir,
  74                                              const char * const name, int namelen,
  75                                              struct ext2_dir_entry_2 ** res_dir, int lock)
  76 {
  77         struct super_block * sb;
  78         unsigned long offset;
  79         struct page * page;
  80         ENTRY;
  81
  82         *res_dir = NULL;
  83         sb = dir->i_sb;
  84
  85         if (namelen > EXT2_NAME_LEN)
  86                 return NULL;
  87
  88         for (page = 0, offset = 0; offset < dir->i_size; page++) {
  89                 struct ext2_dir_entry_2 * de;
  90                 char * dlimit;
  91
  92                 page = obdfs_getpage(dir, offset, 0, lock);
  93                 if ( !page )
  94                         return NULL;
  95
  96                 de = (struct ext2_dir_entry_2 *) page_address(page);
  97                 dlimit = (char *)page_address(page) + PAGE_SIZE;
  98                 while ((char *) de < dlimit) {
  99                         /* this code is executed quadratically often */
 100                         /* do minimal checking `by hand' */
 101                         int de_len;
 102
 103                         if ((char *) de + namelen <= dlimit &&
 104                             ext2_match (namelen, name, de)) {
 105                                 /* found a match -
 106                                    just to be sure, do a full check */
 107                                 if (!obdfs_check_dir_entry("ext2_find_entry",
 108                                                           dir, de, page, offset))
 109                                         goto failure;
 110                                 *res_dir = de;
 111                                 EXIT;
 112                                 return page;
 113                         }
 114                         /* prevent looping on a bad block */
 115                         de_len = le16_to_cpu(de->rec_len);
 116                         if (de_len <= 0)
 117                                 goto failure;
 118                         offset += de_len;
 119                         de = (struct ext2_dir_entry_2 *)
 120                                 ((char *) de + de_len);
 121                 }
 122                 page_cache_release(page);
 123         }
 124
 125 failure:
 126         page_cache_release(page);
 127         EXIT;
 128         return NULL;
 129 }
 130
 131 struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
 132 {
 133         struct inode * inode;
 134         struct ext2_dir_entry_2 * de;
 135         struct page * page;
 136         ENTRY;
 137
 138         if (dentry->d_name.len > EXT2_NAME_LEN)
 139                 return ERR_PTR(-ENAMETOOLONG);
 140
 141         page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, NOLOCK);
 142         inode = NULL;
 143         if ( !page )
 144                 CDEBUG(D_INODE, "No page - negative entry.\n");
 145         if ( page && !de ) {
 146                 CDEBUG(D_INODE, "Danger: PAGE but de.\n");
 147                 return ERR_PTR(-ENOENT);
 148         }
 149         if (page) {
 150                 unsigned long ino = le32_to_cpu(de->inode);
 151                 page_cache_release(page);
 152                 inode = iget(dir->i_sb, ino);
 153
 154                 if (!inode) {
 155                         CDEBUG(D_INODE, "No inode.\n");
 156                         EXIT;
 157                         return ERR_PTR(-EACCES);
 158                 }
 159         }
 160         d_add(dentry, inode);
 161         EXIT;
 162         return NULL;
 163 }
 164
 165
 166 /*
 167  *      ext2_add_entry()
 168  *
 169  * adds a file entry to the specified directory, using the same
 170  * semantics as ext2_find_entry(). It returns NULL if it failed.
 171  *
 172  * NOTE!! The inode part of 'de' is left at 0 - which means you
 173  * may not sleep between calling this and putting something into
 174  * the entry, as someone else might have used it while you slept.
 175
 176  * returns a locked page
 177  */
 178 static struct page *obdfs_add_entry (struct inode * dir,
 179                                      const char * name, int namelen,
 180                                      struct ext2_dir_entry_2 ** res_dir,
 181                                      int *err)
 182 {
 183         unsigned long offset;
 184         unsigned short rec_len;
 185         struct page *page;
 186         struct ext2_dir_entry_2 * de, * de1;
 187         struct super_block * sb;
 188
 189         ENTRY;
 190         *err = -EINVAL;
 191         *res_dir = NULL;
 192         if (!dir || !dir->i_nlink)
 193                 return NULL;
 194         sb = dir->i_sb;
 195
 196         if (!namelen)
 197                 return NULL;
 198         /*
 199          * Is this a busy deleted directory?  Can't create new files if so
 200          */
 201         if (dir->i_size == 0)
 202         {
 203                 *err = -ENOENT;
 204                 return NULL;
 205         }
 206         page = obdfs_getpage(dir, 0, 0, LOCKED);
 207         if (!page) {
 208                 EXIT;
 209                 return NULL;
 210         }
 211         rec_len = EXT2_DIR_REC_LEN(namelen);
 212         offset = 0;
 213         de = (struct ext2_dir_entry_2 *) page_address(page);
 214         *err = -ENOSPC;
 215         while (1) {
 216                 if ((char *)de >= PAGE_SIZE + (char *)page_address(page)) {
 217                         UnlockPage(page);
 218                         page_cache_release(page);
 219                         page = obdfs_getpage(dir, offset, 1, LOCKED);
 220                         if (!page)
 221                                 return NULL;
 222                         if (dir->i_size <= offset) {
 223                                 if (dir->i_size == 0) {
 224                                         *err = -ENOENT;
 225                                         return NULL;
 226                                 }
 227
 228                                 ext2_debug ("creating next block\n");
 229
 230                                 de = (struct ext2_dir_entry_2 *) page_address(page);
 231                                 de->inode = 0;
 232                                 de->rec_len = le16_to_cpu(PAGE_SIZE);
 233                                 dir->i_size = offset + PAGE_SIZE;
 234                                 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 235                                 mark_inode_dirty(dir);
 236                         } else {
 237
 238                                 ext2_debug ("skipping to next block\n");
 239
 240                                 de = (struct ext2_dir_entry_2 *) page_address(page);
 241                         }
 242                 }
 243                 CDEBUG(D_INODE, "\n");
 244                 if (!obdfs_check_dir_entry ("ext2_add_entry", dir, de, page,
 245                                            offset)) {
 246                         *err = -ENOENT;
 247                         page_cache_release(page);
 248                         EXIT;
 249                         return NULL;
 250                 }
 251                 CDEBUG(D_INODE, "\n");
 252                 if (ext2_match (namelen, name, de)) {
 253                                 *err = -EEXIST;
 254                                 UnlockPage(page);
 255                                 page_cache_release(page);
 256                                 EXIT;
 257                                 return NULL;
 258                 }
 259                 CDEBUG(D_INODE, "\n");
 260                 if ((le32_to_cpu(de->inode) == 0 && le16_to_cpu(de->rec_len) >= rec_len) ||
 261                     (le16_to_cpu(de->rec_len) >= EXT2_DIR_REC_LEN(de->name_len) + rec_len)) {
 262                         offset += le16_to_cpu(de->rec_len);
 263                         if (le32_to_cpu(de->inode)) {
 264                                 de1 = (struct ext2_dir_entry_2 *) ((char *) de +
 265                                         EXT2_DIR_REC_LEN(de->name_len));
 266                                 de1->rec_len = cpu_to_le16(le16_to_cpu(de->rec_len) -
 267                                         EXT2_DIR_REC_LEN(de->name_len));
 268                                 de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
 269                                 de = de1;
 270                         }
 271                         CDEBUG(D_INODE, "\n");
 272                         de->inode = 0;
 273                         de->name_len = namelen;
 274                         de->file_type = 0;
 275                         memcpy (de->name, name, namelen);
 276                         CDEBUG(D_INODE, "\n");
 277                         /*
 278                          * XXX shouldn't update any times until successful
 279                          * completion of syscall, but too many callers depend
 280                          * on this.
 281                          *
 282                          * XXX similarly, too many callers depend on
 283                          * ext2_new_inode() setting the times, but error
 284                          * recovery deletes the inode, so the worst that can
 285                          * happen is that the times are slightly out of date
 286                          * and/or different from the directory change time.
 287                          */
 288                         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 289                         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 290                         mark_inode_dirty(dir);
 291                         dir->i_version = ++event;
 292                         *res_dir = de;
 293                         *err = 0;
 294                         PDEBUG(page, "addentry");
 295                         EXIT;
 296                         return page;
 297                 }
 298                 CDEBUG(D_INODE, "\n");
 299                 offset += le16_to_cpu(de->rec_len);
 300                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
 301         }
 302         CDEBUG(D_INODE, "\n");
 303
 304         UnlockPage(page);
 305         page_cache_release(page);
 306         PDEBUG(page, "addentry");
 307         EXIT;
 308         return NULL;
 309 }
 310
 311 /*
 312  * ext2_delete_entry deletes a directory entry by merging it with the
 313  * previous entry
 314  */
 315 static int obdfs_delete_entry (struct ext2_dir_entry_2 * dir,
 316                               struct page * page)
 317 {
 318         struct ext2_dir_entry_2 * de, * pde;
 319         int i;
 320
 321         i = 0;
 322         pde = NULL;
 323         de = (struct ext2_dir_entry_2 *) page_address(page);
 324         while (i < PAGE_SIZE) {
 325                 if (!obdfs_check_dir_entry ("ext2_delete_entry", NULL,
 326                                            de, page, i))
 327                         return -EIO;
 328                 if (de == dir)  {
 329                         if (pde)
 330                                 pde->rec_len =
 331                                         cpu_to_le16(le16_to_cpu(pde->rec_len) +
 332                                                     le16_to_cpu(dir->rec_len));
 333                         else
 334                                 dir->inode = 0;
 335                         return 0;
 336                 }
 337                 i += le16_to_cpu(de->rec_len);
 338                 pde = de;
 339                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
 340         }
 341         return -ENOENT;
 342 }
 343
 344
 345 static inline void ext2_set_de_type(struct super_block *sb,
 346                                 struct ext2_dir_entry_2 *de,
 347                                 umode_t mode) {
 348         if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
 349                 return;
 350         if (S_ISCHR(mode))
 351                 de->file_type = EXT2_FT_CHRDEV;
 352         else if (S_ISBLK(mode))
 353                 de->file_type = EXT2_FT_BLKDEV;
 354         else if (S_ISFIFO(mode))
 355                 de->file_type = EXT2_FT_FIFO;
 356         else if (S_ISLNK(mode))
 357                 de->file_type = EXT2_FT_SYMLINK;
 358         else if (S_ISREG(mode))
 359                 de->file_type = EXT2_FT_REG_FILE;
 360         else if (S_ISDIR(mode))
 361                 de->file_type = EXT2_FT_DIR;
 362 }
 363
 364 /*
 365  * By the time this is called, we already have created
 366  * the directory cache entry for the new file, but it
 367  * is so far negative - it has no inode.
 368  *
 369  * If the create succeeds, we fill in the inode information
 370  * with d_instantiate().
 371  */
 372 int obdfs_create (struct inode * dir, struct dentry * dentry, int mode)
 373 {
 374         struct inode * inode;
 375         struct page *page;
 376         struct ext2_dir_entry_2 * de;
 377         int err = -EIO;
 378         struct obdfs_sb_info *sbi;
 379         ino_t ino;
 380
 381         ENTRY;
 382
 383         sbi = dir->i_sb->u.generic_sbp;
 384         /*
 385          * N.B. Several error exits in ext2_new_inode don't set err.
 386          */
 387         ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
 388         if ( ino == -1 )
 389                 return -1;
 390         inode =  iget(dir->i_sb, ino);
 391         if (!inode) {
 392                 CDEBUG(D_INODE, "No inode, ino %ld\n", ino);
 393                 return err;
 394         }
 395
 396         inode->i_op = &obdfs_inode_ops;
 397         inode->i_mode = mode;
 398         mark_inode_dirty(inode);
 399         page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 400         if (!page) {
 401                 inode->i_nlink--;
 402                 mark_inode_dirty(inode);
 403                 iput (inode);
 404                 EXIT;
 405                 return err;
 406         }
 407         de->inode = cpu_to_le32(inode->i_ino);
 408         ext2_set_de_type(dir->i_sb, de, S_IFREG);
 409         dir->i_version = ++event;
 410         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 411                             dir->i_ino, page, 0);
 412         UnlockPage(page);
 413 #if 0
 414         if (IS_SYNC(dir)) {
 415                 ll_rw_block (WRITE, 1, &bh);
 416                 wait_on_buffer (bh);
 417         }
 418 #endif
 419         page_cache_release(page);
 420         d_instantiate(dentry, inode);
 421         EXIT;
 422         return 0;
 423 }
 424
 425 int obdfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
 426 {
 427         struct inode * inode;
 428         struct page *page;
 429         struct ext2_dir_entry_2 * de;
 430         int err = -EIO;
 431         struct obdfs_sb_info *sbi;
 432
 433         ino_t ino;
 434
 435         ENTRY;
 436
 437         sbi = dir->i_sb->u.generic_sbp;
 438         /*
 439          * N.B. Several error exits in ext2_new_inode don't set err.
 440          */
 441         ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
 442         if ( ino == -1 )
 443                 return -1;
 444         inode =  iget(dir->i_sb, ino);
 445         if (!inode)
 446                 return err;
 447
 448         inode->i_uid = current->fsuid;
 449         init_special_inode(inode, mode, rdev);
 450         page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 451         if (!page)
 452                 goto out_no_entry;
 453         de->inode = cpu_to_le32(inode->i_ino);
 454         dir->i_version = ++event;
 455         ext2_set_de_type(dir->i_sb, de, inode->i_mode);
 456         mark_inode_dirty(inode);
 457         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 458                             dir->i_ino, page, 0);
 459         UnlockPage(page);
 460
 461 #if 0
 462         if (IS_SYNC(dir)) {
 463                 ll_rw_block (WRITE, 1, &bh);
 464                 wait_on_buffer (bh);
 465         }
 466 #endif
 467         d_instantiate(dentry, inode);
 468         page_cache_release(page);
 469         err = 0;
 470 out:
 471         return err;
 472
 473 out_no_entry:
 474         inode->i_nlink--;
 475         mark_inode_dirty(inode);
 476         iput(inode);
 477         goto out;
 478 }
 479
 480 int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 481 {
 482         struct inode * child;
 483         struct page *page, *child_page;
 484         struct ext2_dir_entry_2 * de;
 485         struct obdfs_sb_info *sbi;
 486         int err;
 487         ino_t ino;
 488
 489         ENTRY;
 490         sbi = dir->i_sb->u.generic_sbp;
 491
 492         err = -EMLINK;
 493         if (dir->i_nlink >= EXT2_LINK_MAX)
 494                 goto out;
 495
 496         err = -EIO;
 497         ino = iops(dir)->o_create(sbi->osi_conn_info.conn_id, 0, &err);
 498         if ( ino == -1 )
 499                 return -1;
 500         child =  iget(dir->i_sb, ino);
 501         if (!child)
 502                 return err;
 503
 504
 505         child->i_op = &obdfs_inode_ops;
 506         child->i_size = PAGE_SIZE;
 507         child->i_blocks = 0;
 508         child_page = obdfs_getpage(child, 0, 1, LOCKED);
 509         if (!child_page) {
 510                 child->i_nlink--; /* is this nlink == 0? */
 511                 mark_inode_dirty(child);
 512                 iput (child);
 513                 return err;
 514         }
 515         child->i_blocks = PAGE_SIZE/child->i_sb->s_blocksize;
 516
 517         /* create . and .. */
 518         de = (struct ext2_dir_entry_2 *) page_address(child_page);
 519         de->inode = cpu_to_le32(child->i_ino);
 520         de->name_len = 1;
 521         de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
 522         strcpy (de->name, ".");
 523         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
 524
 525         de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
 526         de->inode = cpu_to_le32(dir->i_ino);
 527         de->rec_len = cpu_to_le16(PAGE_SIZE - EXT2_DIR_REC_LEN(1));
 528         de->name_len = 2;
 529         strcpy (de->name, "..");
 530         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
 531
 532         iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, child->i_ino, child_page, 1);
 533         UnlockPage(child_page);
 534         page_cache_release(child_page);
 535
 536         child->i_nlink = 2;
 537         child->i_mode = S_IFDIR | mode;
 538         if (dir->i_mode & S_ISGID)
 539                 child->i_mode |= S_ISGID;
 540         mark_inode_dirty(child);
 541
 542         /* now deal with the parent */
 543         page = obdfs_add_entry(dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 544         if (!page) {
 545                 goto out_no_entry;
 546         }
 547
 548         de->inode = cpu_to_le32(child->i_ino);
 549         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
 550         dir->i_version = ++event;
 551
 552 #if 0
 553         if (IS_SYNC(dir)) {
 554                 ll_rw_block (WRITE, 1, &bh);
 555                 wait_on_buffer (bh);
 556         }
 557 #endif
 558         dir->i_nlink++;
 559         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 560         mark_inode_dirty(dir);
 561         iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, dir->i_ino, page, 1);
 562         UnlockPage(page);
 563         page_cache_release(page);
 564         d_instantiate(dentry, child);
 565         err = 0;
 566 out:
 567         EXIT;
 568         return err;
 569
 570 out_no_entry:
 571         child->i_nlink = 0;
 572         mark_inode_dirty(child);
 573         iput (child);
 574         EXIT;
 575         goto out;
 576 }
 577
 578
 579 /*
 580  * routine to check that the specified directory is empty (for rmdir)
 581  */
 582 static int empty_dir (struct inode * inode)
 583 {
 584         unsigned long offset;
 585         struct page *page;
 586         struct ext2_dir_entry_2 * de, * de1;
 587         struct super_block * sb;
 588
 589         sb = inode->i_sb;
 590         if (inode->i_size < EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) ||
 591             !(page = obdfs_getpage (inode, 0, 0, NOLOCK))) {
 592                 ext2_warning (inode->i_sb, "empty_dir",
 593                               "bad directory (dir #%lu) - no data block",
 594                               inode->i_ino);
 595                 return 1;
 596         }
 597         de = (struct ext2_dir_entry_2 *) page_address(page);
 598         de1 = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
 599         if (le32_to_cpu(de->inode) != inode->i_ino || !le32_to_cpu(de1->inode) ||
 600             strcmp (".", de->name) || strcmp ("..", de1->name)) {
 601                 ext2_warning (inode->i_sb, "empty_dir",
 602                               "bad directory (dir #%lu) - no `.' or `..'",
 603                               inode->i_ino);
 604                 page_cache_release(page);
 605                 return 1;
 606         }
 607         offset = le16_to_cpu(de->rec_len) + le16_to_cpu(de1->rec_len);
 608         de = (struct ext2_dir_entry_2 *) ((char *) de1 + le16_to_cpu(de1->rec_len));
 609         while (offset < inode->i_size ) {
 610                 if (!page || (void *) de >= (void *) (page_address(page) + PAGE_SIZE)) {
 611                         if (page)
 612                                 page_cache_release(page);
 613                         page = obdfs_getpage(inode, offset, 0, NOLOCK);
 614                         if (!page) {
 615 #if 0
 616                                 ext2_error (sb, "empty_dir",
 617                                             "directory #%lu contains a hole at offset %lu",
 618                                             inode->i_ino, offset);
 619 #endif
 620                                 offset += sb->s_blocksize;
 621                                 continue;
 622                         }
 623                         de = (struct ext2_dir_entry_2 *) page_address(page);
 624                 }
 625                 if (!obdfs_check_dir_entry ("empty_dir", inode, de, page,
 626                                            offset)) {
 627                         page_cache_release(page);
 628                         return 1;
 629                 }
 630                 if (le32_to_cpu(de->inode)) {
 631                         page_cache_release(page);
 632                         return 0;
 633                 }
 634                 offset += le16_to_cpu(de->rec_len);
 635                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
 636         }
 637         page_cache_release(page);
 638         return 1;
 639 }
 640
 641 int obdfs_rmdir (struct inode * dir, struct dentry *dentry)
 642 {
 643         int retval;
 644         struct inode * inode;
 645         struct page *page;
 646         struct ext2_dir_entry_2 * de;
 647         struct obdfs_sb_info *sbi;
 648
 649         ENTRY;
 650         sbi = dir->i_sb->u.generic_sbp;
 651
 652         retval = -ENOENT;
 653         page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, LOCKED);
 654         if (!page)
 655                 goto end_rmdir;
 656
 657         inode = dentry->d_inode;
 658         DQUOT_INIT(inode);
 659
 660         retval = -EIO;
 661         if (le32_to_cpu(de->inode) != inode->i_ino)
 662                 goto end_rmdir;
 663
 664         retval = -ENOTEMPTY;
 665         if (!empty_dir (inode))
 666                 goto end_rmdir;
 667
 668         retval = obdfs_delete_entry (de, page);
 669         dir->i_version = ++event;
 670         if (retval)
 671                 goto end_rmdir;
 672         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 673                             dir->i_ino, page, 0);
 674         UnlockPage(page);
 675 #if 0
 676         if (IS_SYNC(dir)) {
 677                 ll_rw_block (WRITE, 1, &bh);
 678                 wait_on_buffer (bh);
 679         }
 680 #endif
 681         if (inode->i_nlink != 2)
 682                 ext2_warning (inode->i_sb, "ext2_rmdir",
 683                               "empty directory has nlink!=2 (%d)",
 684                               inode->i_nlink);
 685         inode->i_version = ++event;
 686         inode->i_nlink = 0;
 687         inode->i_size = 0;
 688         mark_inode_dirty(inode);
 689         dir->i_nlink--;
 690         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 691         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 692         mark_inode_dirty(dir);
 693         d_delete(dentry);
 694
 695 end_rmdir:
 696         if ( page )
 697                 page_cache_release(page);
 698         EXIT;
 699         return retval;
 700 }
 701
 702 int obdfs_unlink(struct inode * dir, struct dentry *dentry)
 703 {
 704         int retval;
 705         struct inode * inode;
 706         struct page *page;
 707         struct ext2_dir_entry_2 * de;
 708         struct obdfs_sb_info *sbi;
 709
 710         ENTRY;
 711         sbi = dir->i_sb->u.generic_sbp;
 712
 713         retval = -ENOENT;
 714         page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, LOCKED);
 715         if (!page)
 716                 goto end_unlink;
 717
 718         inode = dentry->d_inode;
 719         DQUOT_INIT(inode);
 720
 721         retval = -EIO;
 722         if (le32_to_cpu(de->inode) != inode->i_ino)
 723                 goto end_unlink;
 724
 725         if (!inode->i_nlink) {
 726                 ext2_warning (inode->i_sb, "ext2_unlink",
 727                               "Deleting nonexistent file (%lu), %d",
 728                               inode->i_ino, inode->i_nlink);
 729                 inode->i_nlink = 1;
 730         }
 731         retval = obdfs_delete_entry (de, page);
 732         if (retval)
 733                 goto end_unlink;
 734         dir->i_version = ++event;
 735         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 736                             dir->i_ino, page, 0);
 737         UnlockPage(page);
 738 #if 0
 739         if (IS_SYNC(dir)) {
 740                 ll_rw_block (WRITE, 1, &bh);
 741                 wait_on_buffer (bh);
 742         }
 743 #endif
 744         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 745         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 746         mark_inode_dirty(dir);
 747         inode->i_nlink--;
 748         mark_inode_dirty(inode);
 749         inode->i_ctime = dir->i_ctime;
 750         retval = 0;
 751         d_delete(dentry);       /* This also frees the inode */
 752
 753 end_unlink:
 754         if (page)
 755                 page_cache_release(page);
 756         EXIT;
 757         return retval;
 758 }
 759
 760 int obdfs_symlink (struct inode * dir, struct dentry *dentry, const char * symname)
 761 {
 762         struct ext2_dir_entry_2 * de;
 763         struct inode * inode;
 764         struct page* page = NULL, * name_page = NULL;
 765         char * link;
 766         int i, l, err = -EIO;
 767         char c;
 768         struct obdfs_sb_info *sbi;
 769         ino_t ino;
 770
 771         ENTRY;
 772
 773         sbi = dir->i_sb->u.generic_sbp;
 774         /*
 775          * N.B. Several error exits in ext2_new_inode don't set err.
 776          */
 777         ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
 778         if ( ino == -1 )
 779                 return -1;
 780         inode =  iget(dir->i_sb, ino);
 781         if (!inode)
 782                 return err;
 783
 784         inode->i_mode = S_IFLNK | S_IRWXUGO;
 785         inode->i_op = &obdfs_inode_ops;
 786         for (l = 0; l < inode->i_sb->s_blocksize - 1 &&
 787              symname [l]; l++)
 788                 ;
 789         if (l >= sizeof (inode->u.ext2_i.i_data)) {
 790
 791                 ext2_debug ("l=%d, normal symlink\n", l);
 792
 793                 name_page = obdfs_getpage(inode, 0, 1, LOCKED);
 794                 if (!name_page) {
 795                         inode->i_nlink--;
 796                         mark_inode_dirty(inode);
 797                         iput (inode);
 798                         return err;
 799                 }
 800                 link = (char *)page_address(name_page);
 801         } else {
 802                 link = (char *) inode->u.ext2_i.i_data;
 803
 804                 ext2_debug ("l=%d, fast symlink\n", l);
 805
 806         }
 807         i = 0;
 808         while (i < inode->i_sb->s_blocksize - 1 && (c = *(symname++)))
 809                 link[i++] = c;
 810         link[i] = 0;
 811         if (name_page) {
 812                 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 813                                     inode->i_ino, name_page, 1);
 814                 PDEBUG(name_page, "symlink");
 815                 UnlockPage(name_page);
 816                 page_cache_release(name_page);
 817         }
 818         inode->i_size = i;
 819         mark_inode_dirty(inode);
 820
 821         page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 822         if (!page)
 823                 goto out_no_entry;
 824         de->inode = cpu_to_le32(inode->i_ino);
 825         ext2_set_de_type(dir->i_sb, de, S_IFLNK);
 826         dir->i_version = ++event;
 827         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 828                             dir->i_ino, page, 1);
 829         UnlockPage(page);
 830 #if 0
 831         if (IS_SYNC(dir)) {
 832                 ll_rw_block (WRITE, 1, &bh);
 833                 wait_on_buffer (bh);
 834         }
 835 #endif
 836         d_instantiate(dentry, inode);
 837         err = 0;
 838 out:
 839         return err;
 840
 841 out_no_entry:
 842         inode->i_nlink--;
 843         mark_inode_dirty(inode);
 844         iput (inode);
 845         goto out;
 846 }
 847
 848 int obdfs_link (struct dentry * old_dentry,
 849                 struct inode * dir, struct dentry *dentry)
 850 {
 851         struct inode *inode = old_dentry->d_inode;
 852         struct ext2_dir_entry_2 * de;
 853         struct page *page;
 854         int err;
 855         struct obdfs_sb_info *sbi;
 856
 857         ENTRY;
 858         sbi = dir->i_sb->u.generic_sbp;
 859
 860         if (S_ISDIR(inode->i_mode))
 861                 return -EPERM;
 862
 863         if (inode->i_nlink >= EXT2_LINK_MAX)
 864                 return -EMLINK;
 865
 866         page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 867         if (!page)
 868                 return err;
 869
 870         de->inode = cpu_to_le32(inode->i_ino);
 871         ext2_set_de_type(dir->i_sb, de, inode->i_mode);
 872         dir->i_version = ++event;
 873         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 874                             dir->i_ino, page, 0);
 875         UnlockPage(page);
 876
 877 #if 0
 878         if (IS_SYNC(dir)) {
 879                 ll_rw_block (WRITE, 1, &bh);
 880                 wait_on_buffer (bh);
 881         }
 882 #endif
 883         page_cache_release(page);
 884         inode->i_nlink++;
 885         inode->i_ctime = CURRENT_TIME;
 886         mark_inode_dirty(inode);
 887         inode->i_count++;
 888         d_instantiate(dentry, inode);
 889         return 0;
 890 }
 891
 892 #define PARENT_INO(buffer) \
 893         ((struct ext2_dir_entry_2 *) ((char *) buffer + \
 894         le16_to_cpu(((struct ext2_dir_entry_2 *) buffer)->rec_len)))->inode
 895
 896 /*
 897  * Anybody can rename anything with this: the permission checks are left to the
 898  * higher-level routines.
 899  */
 900 int obdfs_rename (struct inode * old_dir, struct dentry *old_dentry,
 901                            struct inode * new_dir, struct dentry *new_dentry)
 902 {
 903         struct inode * old_inode, * new_inode;
 904         struct page * old_page, * new_page, * dir_page;
 905         struct ext2_dir_entry_2 * old_de, * new_de;
 906         int retval;
 907         struct obdfs_sb_info *sbi;
 908
 909         ENTRY;
 910         sbi = old_dir->i_sb->u.generic_sbp;
 911
 912         new_page = dir_page = NULL;
 913
 914         /* does the old entry exist? - if not get out */
 915         old_page = obdfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de, NOLOCK);
 916         PDEBUG(old_page, "rename - old page");
 917         /*
 918          *  Check for inode number is _not_ due to possible IO errors.
 919          *  We might rmdir the source, keep it as pwd of some process
 920          *  and merrily kill the link to whatever was created under the
 921          *  same name. Goodbye sticky bit ;-<
 922          */
 923         old_inode = old_dentry->d_inode;
 924         retval = -ENOENT;
 925         if (!old_page || le32_to_cpu(old_de->inode) != old_inode->i_ino)
 926                 goto end_rename;
 927
 928         /* find new inode */
 929         new_inode = new_dentry->d_inode;
 930         new_page = obdfs_find_entry (new_dir, new_dentry->d_name.name,
 931                                 new_dentry->d_name.len, &new_de, NOLOCK);
 932         PDEBUG(new_page, "rename - new page ");
 933         if (new_page) {
 934                 if (!new_inode) {
 935                         page_cache_release(new_page);
 936                         new_page = NULL;
 937                 } else {
 938                         DQUOT_INIT(new_inode);
 939                 }
 940         }
 941         /* in this case we to check more ... */
 942         if (S_ISDIR(old_inode->i_mode)) {
 943                 /* can only rename into empty new directory */
 944                 if (new_inode) {
 945                         retval = -ENOTEMPTY;
 946                         if (!empty_dir (new_inode))
 947                                 goto end_rename;
 948                 }
 949                 retval = -EIO;
 950                 dir_page= obdfs_getpage (old_inode, 0, 0, LOCKED);
 951                 PDEBUG(dir_page, "rename dir page");
 952
 953                 if (!dir_page)
 954                         goto end_rename;
 955                 if (le32_to_cpu(PARENT_INO(page_address(dir_page))) != old_dir->i_ino)
 956                         goto end_rename;
 957                 retval = -EMLINK;
 958                 if (!new_inode && new_dir!=old_dir &&
 959                                 new_dir->i_nlink >= EXT2_LINK_MAX)
 960                         goto end_rename;
 961         }
 962         /* create the target dir entry */
 963         if (!new_page) {
 964                 new_page = obdfs_add_entry (new_dir, new_dentry->d_name.name,
 965                                         new_dentry->d_name.len, &new_de,
 966                                         &retval);
 967                 PDEBUG(new_page, "rename new page");
 968                 if (!new_page)
 969                         goto end_rename;
 970         }
 971         new_dir->i_version = ++event;
 972
 973         /*
 974          * remove the old entry
 975          */
 976         new_de->inode = le32_to_cpu(old_inode->i_ino);
 977         if (EXT2_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
 978                                       EXT2_FEATURE_INCOMPAT_FILETYPE))
 979                 new_de->file_type = old_de->file_type;
 980
 981         obdfs_delete_entry (old_de, old_page);
 982
 983         old_dir->i_version = ++event;
 984         if (new_inode) {
 985                 new_inode->i_nlink--;
 986                 new_inode->i_ctime = CURRENT_TIME;
 987                 mark_inode_dirty(new_inode);
 988         }
 989         old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
 990         old_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 991         mark_inode_dirty(old_dir);
 992         if (dir_page) {
 993                 PARENT_INO(page_address(dir_page)) = le32_to_cpu(new_dir->i_ino);
 994                 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
 995                             old_inode->i_ino, dir_page, 0);
 996                 old_dir->i_nlink--;
 997                 mark_inode_dirty(old_dir);
 998                 if (new_inode) {
 999                         new_inode->i_nlink--;
1000                         mark_inode_dirty(new_inode);
1001                 } else {
1002                         new_dir->i_nlink++;
1003                         new_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
1004                         mark_inode_dirty(new_dir);
1005                 }
1006         }
1007         if ( old_page != new_page ) {
1008                 unsigned long offset = old_page->offset;
1009                 /* lock the old_page and release unlocked copy */
1010                 CDEBUG(D_INODE, "old_page at %p\n", old_page);
1011                 page_cache_release(old_page);
1012                 old_page = obdfs_getpage(old_dir, offset, 0, LOCKED);
1013                 CDEBUG(D_INODE, "old_page at %p\n", old_page);
1014                 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
1015                                     old_dir->i_ino, old_page, 0);
1016         }
1017 #if 0
1018         if (IS_SYNC(old_dir)) {
1019                 ll_rw_block (WRITE, 1, &old_bh);
1020                 wait_on_buffer (old_bh);
1021         }
1022 #endif
1023         sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
1024                             new_dir->i_ino, new_page, 0);
1025 #if 0
1026         if (IS_SYNC(new_dir)) {
1027                 ll_rw_block (WRITE, 1, &new_bh);
1028                 wait_on_buffer (new_bh);
1029         }
1030 #endif
1031
1032         retval = 0;
1033
1034 end_rename:
1035         if (old_page && PageLocked(old_page) )
1036                 UnlockPage(old_page);
1037         if (old_page)
1038                 page_cache_release(old_page);
1039         if (new_page && PageLocked(new_page) )
1040                 UnlockPage(new_page);
1041         if (new_page)
1042                 page_cache_release(new_page);
1043         if (dir_page && PageLocked(dir_page) )
1044                 UnlockPage(dir_page);
1045         if (dir_page)
1046                 page_cache_release(dir_page);
1047
1048
1049         return retval;
1050 }