lustre/obdfs/namei.c

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