lustre/llite/dir.c

   1 /*
   2  *
   3  * Copyright (C) 1992, 1993, 1994, 1995
   4  * Remy Card (card@masi.ibp.fr)
   5  * Laboratoire MASI - Institut Blaise Pascal
   6  * Universite Pierre et Marie Curie (Paris VI)
   7  *
   8  *  from
   9  *
  10  *  linux/fs/minix/dir.c
  11  *  linux/fs/ext2/dir.c
  12  *
  13  *  Copyright (C) 1991, 1992  Linus Torvalds
  14  *
  15  *  ext2 directory handling functions
  16  *
  17  *  Big-endian to little-endian byte-swapping/bitmaps by
  18  *        David S. Miller (davem@caip.rutgers.edu), 1995
  19  *
  20  *  All code that works with directory layout had been switched to pagecache
  21  *  and moved here. AV
  22  *
  23  *  Adapted for Lustre Light
  24  *  Copyright (C) 2002, Cluster File Systems, Inc.
  25  *
  26  */
  27
  28 #include <linux/fs.h>
  29 #include <linux/ext2_fs.h>
  30 #include <linux/pagemap.h>
  31 #include <linux/mm.h>
  32 #include <linux/obd_support.h>
  33 #include <linux/locks.h>
  34 #include <asm/uaccess.h>
  35 #include <linux/lustre_lib.h>
  36 #include <linux/lustre_idl.h>
  37 #include <linux/lustre_mds.h>
  38 #include <linux/lustre_light.h>
  39
  40 typedef struct ext2_dir_entry_2 ext2_dirent;
  41
  42 #define PageChecked(page)        test_bit(PG_checked, &(page)->flags)
  43 #define SetPageChecked(page)     set_bit(PG_checked, &(page)->flags)
  44
  45
  46 static int ll_dir_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
  47 {
  48         return 0;
  49 }
  50
  51 /* returns the page unlocked, but with a reference */
  52 static int ll_dir_readpage(struct file *file, struct page *page)
  53 {
  54         struct inode *inode = page->mapping->host;
  55         struct ll_sb_info *sbi = ll_i2sbi(inode);
  56         char *buf;
  57         __u64 offset;
  58         int rc = 0;
  59         struct ptlrep_hdr *hdr;
  60
  61         ENTRY;
  62
  63         if ( ((inode->i_size + PAGE_CACHE_SIZE -1)>>PAGE_SHIFT)
  64              <= page->index) {
  65                 memset(kmap(page), 0, PAGE_CACHE_SIZE);
  66                 kunmap(page);
  67                 goto readpage_out;
  68         }
  69
  70         if (Page_Uptodate(page)) {
  71                 EXIT;
  72                 goto readpage_out;
  73         }
  74
  75         offset = page->index << PAGE_SHIFT;
  76         buf = kmap(page);
  77         rc = mdc_readpage(sbi->ll_peer_ptr, inode->i_ino, S_IFDIR, offset, buf,
  78                           NULL, &hdr);
  79         kunmap(page);
  80         if ( rc ) {
  81                 EXIT;
  82                 goto readpage_out;
  83         }
  84
  85         if ((rc = hdr->status)) {
  86                 EXIT;
  87                 goto readpage_out;
  88         }
  89
  90         /* PDEBUG(page, "READ"); */
  91
  92         SetPageUptodate(page);
  93  readpage_out:
  94         obd_unlock_page(page);
  95         EXIT;
  96         return rc;
  97 } /* ll_dir_readpage */
  98
  99 struct address_space_operations ll_dir_aops = {
 100         readpage: ll_dir_readpage,
 101         prepare_write: ll_dir_prepare_write
 102 };
 103
 104 int waitfor_one_page(struct page *page)
 105 {
 106         int error = 0;
 107         struct buffer_head *bh, *head = page->buffers;
 108
 109         bh = head;
 110         do {
 111                 wait_on_buffer(bh);
 112                 if (buffer_req(bh) && !buffer_uptodate(bh))
 113                         error = -EIO;
 114         } while ((bh = bh->b_this_page) != head);
 115         return error;
 116 }
 117
 118 /*
 119  * ext2 uses block-sized chunks. Arguably, sector-sized ones would be
 120  * more robust, but we have what we have
 121  */
 122 static inline unsigned ext2_chunk_size(struct inode *inode)
 123 {
 124         //return inode->i_sb->s_blocksize;
 125         return PAGE_SIZE;
 126 }
 127
 128 static inline void ext2_put_page(struct page *page)
 129 {
 130         kunmap(page);
 131         page_cache_release(page);
 132 }
 133
 134 static inline unsigned long dir_pages(struct inode *inode)
 135 {
 136         return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
 137 }
 138
 139 extern void set_page_clean(struct page *page);
 140
 141 static int ext2_commit_chunk(struct page *page, unsigned from, unsigned to)
 142 {
 143         struct inode *dir = page->mapping->host;
 144         int err = 0;
 145
 146         dir->i_version = ++event;
 147         dir->i_size = (page->index << PAGE_CACHE_SHIFT) + to;
 148         SetPageUptodate(page);
 149         set_page_clean(page);
 150
 151         //page->mapping->a_ops->commit_write(NULL, page, from, to);
 152         //if (IS_SYNC(dir))
 153         //      err = waitfor_one_page(page);
 154         return err;
 155 }
 156
 157 static void ext2_check_page(struct page *page)
 158 {
 159         struct inode *dir = page->mapping->host;
 160         unsigned chunk_size = ext2_chunk_size(dir);
 161         char *kaddr = page_address(page);
 162         //      u32 max_inumber = le32_to_cpu(sb->u.ext2_sb.s_es->s_inodes_count);
 163         unsigned offs, rec_len;
 164         unsigned limit = PAGE_CACHE_SIZE;
 165         ext2_dirent *p;
 166         char *error;
 167
 168         if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
 169                 limit = dir->i_size & ~PAGE_CACHE_MASK;
 170                 if (limit & (chunk_size - 1))
 171                         goto Ebadsize;
 172                 for (offs = limit; offs<PAGE_CACHE_SIZE; offs += chunk_size) {
 173                         ext2_dirent *p = (ext2_dirent*)(kaddr + offs);
 174                         p->rec_len = cpu_to_le16(chunk_size);
 175                 }
 176                 if (!limit)
 177                         goto out;
 178         }
 179         for (offs = 0; offs <= limit - EXT2_DIR_REC_LEN(1); offs += rec_len) {
 180                 p = (ext2_dirent *)(kaddr + offs);
 181                 rec_len = le16_to_cpu(p->rec_len);
 182
 183                 if (rec_len < EXT2_DIR_REC_LEN(1))
 184                         goto Eshort;
 185                 if (rec_len & 3)
 186                         goto Ealign;
 187                 if (rec_len < EXT2_DIR_REC_LEN(p->name_len))
 188                         goto Enamelen;
 189                 if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
 190                         goto Espan;
 191                 //              if (le32_to_cpu(p->inode) > max_inumber)
 192                 //goto Einumber;
 193         }
 194         if (offs != limit)
 195                 goto Eend;
 196 out:
 197         SetPageChecked(page);
 198         return;
 199
 200         /* Too bad, we had an error */
 201
 202 Ebadsize:
 203         printk("ext2_check_page"
 204                 "size of directory #%lu is not a multiple of chunk size",
 205                 dir->i_ino
 206         );
 207         goto fail;
 208 Eshort:
 209         error = "rec_len is smaller than minimal";
 210         goto bad_entry;
 211 Ealign:
 212         error = "unaligned directory entry";
 213         goto bad_entry;
 214 Enamelen:
 215         error = "rec_len is too small for name_len";
 216         goto bad_entry;
 217 Espan:
 218         error = "directory entry across blocks";
 219         goto bad_entry;
 220         //Einumber:
 221         // error = "inode out of bounds";
 222 bad_entry:
 223         printk("ext2_check_page: bad entry in directory #%lu: %s - "
 224                 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
 225                 dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
 226                 (unsigned long) le32_to_cpu(p->inode),
 227                 rec_len, p->name_len);
 228         goto fail;
 229 Eend:
 230         p = (ext2_dirent *)(kaddr + offs);
 231         printk("ext2_check_page"
 232                 "entry in directory #%lu spans the page boundary"
 233                 "offset=%lu, inode=%lu",
 234                 dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs,
 235                 (unsigned long) le32_to_cpu(p->inode));
 236 fail:
 237         SetPageChecked(page);
 238         SetPageError(page);
 239 }
 240
 241 static struct page * ext2_get_page(struct inode *dir, unsigned long n)
 242 {
 243         struct address_space *mapping = dir->i_mapping;
 244         struct page *page = read_cache_page(mapping, n,
 245                                 (filler_t*)mapping->a_ops->readpage, NULL);
 246         if (!IS_ERR(page)) {
 247                 wait_on_page(page);
 248                 kmap(page);
 249                 if (!Page_Uptodate(page))
 250                         goto fail;
 251                 if (!PageChecked(page))
 252                         ext2_check_page(page);
 253                 if (PageError(page))
 254                         goto fail;
 255         }
 256         return page;
 257
 258 fail:
 259         ext2_put_page(page);
 260         return ERR_PTR(-EIO);
 261 }
 262
 263 /*
 264  * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
 265  *
 266  * len <= EXT2_NAME_LEN and de != NULL are guaranteed by caller.
 267  */
 268 static inline int ext2_match (int len, const char * const name,
 269                                         struct ext2_dir_entry_2 * de)
 270 {
 271         if (len != de->name_len)
 272                 return 0;
 273         if (!de->inode)
 274                 return 0;
 275         return !memcmp(name, de->name, len);
 276 }
 277
 278 /*
 279  * p is at least 6 bytes before the end of page
 280  */
 281 static inline ext2_dirent *ext2_next_entry(ext2_dirent *p)
 282 {
 283         return (ext2_dirent *)((char*)p + le16_to_cpu(p->rec_len));
 284 }
 285
 286 static inline unsigned
 287 ext2_validate_entry(char *base, unsigned offset, unsigned mask)
 288 {
 289         ext2_dirent *de = (ext2_dirent*)(base + offset);
 290         ext2_dirent *p = (ext2_dirent*)(base + (offset&mask));
 291         while ((char*)p < (char*)de)
 292                 p = ext2_next_entry(p);
 293         return (char *)p - base;
 294 }
 295
 296 static unsigned char ext2_filetype_table[EXT2_FT_MAX] = {
 297         [EXT2_FT_UNKNOWN]       DT_UNKNOWN,
 298         [EXT2_FT_REG_FILE]      DT_REG,
 299         [EXT2_FT_DIR]           DT_DIR,
 300         [EXT2_FT_CHRDEV]        DT_CHR,
 301         [EXT2_FT_BLKDEV]        DT_BLK,
 302         [EXT2_FT_FIFO]          DT_FIFO,
 303         [EXT2_FT_SOCK]          DT_SOCK,
 304         [EXT2_FT_SYMLINK]       DT_LNK,
 305 };
 306
 307 static unsigned int ll_dt2fmt[DT_WHT + 1] = {
 308         [EXT2_FT_UNKNOWN]       0,
 309         [EXT2_FT_REG_FILE]      S_IFREG,
 310         [EXT2_FT_DIR]           S_IFDIR,
 311         [EXT2_FT_CHRDEV]        S_IFCHR,
 312         [EXT2_FT_BLKDEV]        S_IFBLK,
 313         [EXT2_FT_FIFO]          S_IFIFO,
 314         [EXT2_FT_SOCK]          S_IFSOCK,
 315         [EXT2_FT_SYMLINK]       S_IFLNK
 316 };
 317
 318 #define S_SHIFT 12
 319 static unsigned char ext2_type_by_mode[S_IFMT >> S_SHIFT] = {
 320         [S_IFREG >> S_SHIFT]    EXT2_FT_REG_FILE,
 321         [S_IFDIR >> S_SHIFT]    EXT2_FT_DIR,
 322         [S_IFCHR >> S_SHIFT]    EXT2_FT_CHRDEV,
 323         [S_IFBLK >> S_SHIFT]    EXT2_FT_BLKDEV,
 324         [S_IFIFO >> S_SHIFT]    EXT2_FT_FIFO,
 325         [S_IFSOCK >> S_SHIFT]   EXT2_FT_SOCK,
 326         [S_IFLNK >> S_SHIFT]    EXT2_FT_SYMLINK,
 327 };
 328
 329 static inline void ext2_set_de_type(ext2_dirent *de, struct inode *inode)
 330 {
 331         mode_t mode = inode->i_mode;
 332         de->file_type = ext2_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
 333 }
 334
 335 int
 336 new_ll_readdir (struct file * filp, void * dirent, filldir_t filldir)
 337 {
 338         loff_t pos = filp->f_pos;
 339         struct inode *inode = filp->f_dentry->d_inode;
 340         // XXX struct super_block *sb = inode->i_sb;
 341         unsigned offset = pos & ~PAGE_CACHE_MASK;
 342         unsigned long n = pos >> PAGE_CACHE_SHIFT;
 343         unsigned long npages = dir_pages(inode);
 344         unsigned chunk_mask = ~(ext2_chunk_size(inode)-1);
 345         unsigned char *types = NULL;
 346         int need_revalidate = (filp->f_version != inode->i_version);
 347
 348         if (pos > inode->i_size - EXT2_DIR_REC_LEN(1))
 349                 goto done;
 350
 351         types = ext2_filetype_table;
 352
 353         for ( ; n < npages; n++, offset = 0) {
 354                 char *kaddr, *limit;
 355                 ext2_dirent *de;
 356                 struct page *page = ext2_get_page(inode, n);
 357
 358                 if (IS_ERR(page))
 359                         continue;
 360                 kaddr = page_address(page);
 361                 if (need_revalidate) {
 362                         offset = ext2_validate_entry(kaddr, offset, chunk_mask);
 363                         need_revalidate = 0;
 364                 }
 365                 de = (ext2_dirent *)(kaddr+offset);
 366                 limit = kaddr + PAGE_CACHE_SIZE - EXT2_DIR_REC_LEN(1);
 367                 for ( ;(char*)de <= limit; de = ext2_next_entry(de))
 368                         if (de->inode) {
 369                                 int over;
 370                                 unsigned char d_type = DT_UNKNOWN;
 371
 372                                 if (types && de->file_type < EXT2_FT_MAX)
 373                                         d_type = types[de->file_type];
 374
 375                                 offset = (char *)de - kaddr;
 376                                 over = filldir(dirent, de->name, de->name_len,
 377                                                 (n<<PAGE_CACHE_SHIFT) | offset,
 378                                                 le32_to_cpu(de->inode), d_type);
 379                                 if (over) {
 380                                         ext2_put_page(page);
 381                                         goto done;
 382                                 }
 383                         }
 384                 ext2_put_page(page);
 385         }
 386
 387 done:
 388         filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
 389         filp->f_version = inode->i_version;
 390         UPDATE_ATIME(inode);
 391         return 0;
 392 }
 393
 394 /*
 395  *      ext2_find_entry()
 396  *
 397  * finds an entry in the specified directory with the wanted name. It
 398  * returns the page in which the entry was found, and the entry itself
 399  * (as a parameter - res_dir). Page is returned mapped and unlocked.
 400  * Entry is guaranteed to be valid.
 401  */
 402 struct ext2_dir_entry_2 * ext2_find_entry (struct inode * dir,
 403                         struct dentry *dentry, struct page ** res_page)
 404 {
 405         const char *name = dentry->d_name.name;
 406         int namelen = dentry->d_name.len;
 407         unsigned reclen = EXT2_DIR_REC_LEN(namelen);
 408         unsigned long start, n;
 409         unsigned long npages = dir_pages(dir);
 410         struct page *page = NULL;
 411         ext2_dirent * de;
 412
 413         /* OFFSET_CACHE */
 414         *res_page = NULL;
 415
 416         //      start = dir->u.ext2_i.i_dir_start_lookup;
 417         start = 0;
 418         if (start >= npages)
 419                 start = 0;
 420         n = start;
 421         do {
 422                 char *kaddr;
 423                 page = ext2_get_page(dir, n);
 424                 if (!IS_ERR(page)) {
 425                         kaddr = page_address(page);
 426                         de = (ext2_dirent *) kaddr;
 427                         kaddr += PAGE_CACHE_SIZE - reclen;
 428                         while ((char *) de <= kaddr) {
 429                                 if (ext2_match (namelen, name, de))
 430                                         goto found;
 431                                 de = ext2_next_entry(de);
 432                         }
 433                         ext2_put_page(page);
 434                 }
 435                 if (++n >= npages)
 436                         n = 0;
 437         } while (n != start);
 438         return NULL;
 439
 440 found:
 441         *res_page = page;
 442         //      dir->u.ext2_i.i_dir_start_lookup = n;
 443         return de;
 444 }
 445
 446 struct ext2_dir_entry_2 * ext2_dotdot (struct inode *dir, struct page **p)
 447 {
 448         struct page *page = ext2_get_page(dir, 0);
 449         ext2_dirent *de = NULL;
 450
 451         if (!IS_ERR(page)) {
 452                 de = ext2_next_entry((ext2_dirent *) page_address(page));
 453                 *p = page;
 454         }
 455         return de;
 456 }
 457
 458 ino_t ll_inode_by_name(struct inode * dir, struct dentry *dentry, int *type)
 459 {
 460         ino_t res = 0;
 461         struct ext2_dir_entry_2 * de;
 462         struct page *page;
 463
 464         de = ext2_find_entry (dir, dentry, &page);
 465         if (de) {
 466                 res = le32_to_cpu(de->inode);
 467                 *type = ll_dt2fmt[de->file_type];
 468                 kunmap(page);
 469                 page_cache_release(page);
 470         }
 471         return res;
 472 }
 473
 474 /* Releases the page */
 475 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
 476                         struct page *page, struct inode *inode)
 477 {
 478         unsigned from = (char *) de - (char *) page_address(page);
 479         unsigned to = from + le16_to_cpu(de->rec_len);
 480         int err;
 481
 482         lock_page(page);
 483         err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
 484         if (err)
 485                 BUG();
 486         de->inode = cpu_to_le32(inode->i_ino);
 487         ext2_set_de_type (de, inode);
 488         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 489         err = ext2_commit_chunk(page, from, to);
 490         UnlockPage(page);
 491         ext2_put_page(page);
 492 }
 493
 494 /*
 495  *      Parent is locked.
 496  */
 497 int ll_add_link (struct dentry *dentry, struct inode *inode)
 498 {
 499         struct inode *dir = dentry->d_parent->d_inode;
 500         const char *name = dentry->d_name.name;
 501         int namelen = dentry->d_name.len;
 502         unsigned reclen = EXT2_DIR_REC_LEN(namelen);
 503         unsigned short rec_len, name_len;
 504         struct page *page = NULL;
 505         ext2_dirent * de;
 506         unsigned long npages = dir_pages(dir);
 507         unsigned long n;
 508         char *kaddr;
 509         unsigned from, to;
 510         int err;
 511
 512         /* We take care of directory expansion in the same loop */
 513         for (n = 0; n <= npages; n++) {
 514                 page = ext2_get_page(dir, n);
 515                 err = PTR_ERR(page);
 516                 if (IS_ERR(page))
 517                         goto out;
 518                 kaddr = page_address(page);
 519                 de = (ext2_dirent *)kaddr;
 520                 kaddr += PAGE_CACHE_SIZE - reclen;
 521                 while ((char *)de <= kaddr) {
 522                         err = -EEXIST;
 523                         if (ext2_match (namelen, name, de))
 524                                 goto out_page;
 525                         name_len = EXT2_DIR_REC_LEN(de->name_len);
 526                         rec_len = le16_to_cpu(de->rec_len);
 527                         if ( n==npages && rec_len == 0) {
 528                                 printk("Fatal dir behaviour\n");
 529                                 goto out_page;
 530                         }
 531                         if (!de->inode && rec_len >= reclen)
 532                                 goto got_it;
 533                         if (rec_len >= name_len + reclen)
 534                                 goto got_it;
 535                         de = (ext2_dirent *) ((char *) de + rec_len);
 536                 }
 537                 ext2_put_page(page);
 538         }
 539         BUG();
 540         return -EINVAL;
 541
 542 got_it:
 543         from = (char*)de - (char*)page_address(page);
 544         to = from + rec_len;
 545         lock_page(page);
 546         err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
 547         if (err)
 548                 goto out_unlock;
 549         if (de->inode) {
 550                 ext2_dirent *de1 = (ext2_dirent *) ((char *) de + name_len);
 551                 de1->rec_len = cpu_to_le16(rec_len - name_len);
 552                 de->rec_len = cpu_to_le16(name_len);
 553                 de = de1;
 554         }
 555         de->name_len = namelen;
 556         memcpy (de->name, name, namelen);
 557         de->inode = cpu_to_le32(inode->i_ino);
 558         ext2_set_de_type (de, inode);
 559         CDEBUG(D_INODE, "type set to %o\n", de->file_type);
 560         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 561         err = ext2_commit_chunk(page, from, to);
 562
 563         // change_inode happens with the commit_chunk
 564         /* XXX OFFSET_CACHE */
 565
 566 out_unlock:
 567         UnlockPage(page);
 568 out_page:
 569         ext2_put_page(page);
 570 out:
 571         return err;
 572 }
 573
 574 /*
 575  * ext2_delete_entry deletes a directory entry by merging it with the
 576  * previous entry. Page is up-to-date. Releases the page.
 577  */
 578 int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
 579 {
 580         struct address_space *mapping = page->mapping;
 581         struct inode *inode = mapping->host;
 582         char *kaddr = page_address(page);
 583         unsigned from = ((char*)dir - kaddr) & ~(ext2_chunk_size(inode)-1);
 584         unsigned to = ((char*)dir - kaddr) + le16_to_cpu(dir->rec_len);
 585         ext2_dirent * pde = NULL;
 586         ext2_dirent * de = (ext2_dirent *) (kaddr + from);
 587         int err;
 588
 589         while ((char*)de < (char*)dir) {
 590                 pde = de;
 591                 de = ext2_next_entry(de);
 592         }
 593         if (pde)
 594                 from = (char*)pde - (char*)page_address(page);
 595         lock_page(page);
 596         err = mapping->a_ops->prepare_write(NULL, page, from, to);
 597         if (err)
 598                 BUG();
 599         if (pde)
 600                 pde->rec_len = cpu_to_le16(to-from);
 601         dir->inode = 0;
 602         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 603         err = ext2_commit_chunk(page, from, to);
 604         UnlockPage(page);
 605         ext2_put_page(page);
 606         return err;
 607 }
 608
 609 /*
 610  * Set the first fragment of directory.
 611  */
 612 int ext2_make_empty(struct inode *inode, struct inode *parent)
 613 {
 614         struct address_space *mapping = inode->i_mapping;
 615         struct page *page = grab_cache_page(mapping, 0);
 616         unsigned chunk_size = ext2_chunk_size(inode);
 617         struct ext2_dir_entry_2 * de;
 618         char *base;
 619         int err;
 620         ENTRY;
 621
 622         if (!page)
 623                 return -ENOMEM;
 624         err = mapping->a_ops->prepare_write(NULL, page, 0, chunk_size);
 625         if (err)
 626                 goto fail;
 627
 628         base = page_address(page);
 629
 630         de = (struct ext2_dir_entry_2 *) base;
 631         de->name_len = 1;
 632         de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(1));
 633         memcpy (de->name, ".\0\0", 4);
 634         de->inode = cpu_to_le32(inode->i_ino);
 635         ext2_set_de_type (de, inode);
 636
 637         de = (struct ext2_dir_entry_2 *) (base + EXT2_DIR_REC_LEN(1));
 638         de->name_len = 2;
 639         de->rec_len = cpu_to_le16(chunk_size - EXT2_DIR_REC_LEN(1));
 640         de->inode = cpu_to_le32(parent->i_ino);
 641         memcpy (de->name, "..\0", 4);
 642         ext2_set_de_type (de, inode);
 643
 644         err = ext2_commit_chunk(page, 0, chunk_size);
 645 fail:
 646         UnlockPage(page);
 647         page_cache_release(page);
 648         ENTRY;
 649         return err;
 650 }
 651
 652 /*
 653  * routine to check that the specified directory is empty (for rmdir)
 654  */
 655 int ext2_empty_dir (struct inode * inode)
 656 {
 657         struct page *page = NULL;
 658         unsigned long i, npages = dir_pages(inode);
 659
 660         for (i = 0; i < npages; i++) {
 661                 char *kaddr;
 662                 ext2_dirent * de;
 663                 page = ext2_get_page(inode, i);
 664
 665                 if (IS_ERR(page))
 666                         continue;
 667
 668                 kaddr = page_address(page);
 669                 de = (ext2_dirent *)kaddr;
 670                 kaddr += PAGE_CACHE_SIZE-EXT2_DIR_REC_LEN(1);
 671
 672                 while ((char *)de <= kaddr) {
 673                         if (de->inode != 0) {
 674                                 /* check for . and .. */
 675                                 if (de->name[0] != '.')
 676                                         goto not_empty;
 677                                 if (de->name_len > 2)
 678                                         goto not_empty;
 679                                 if (de->name_len < 2) {
 680                                         if (de->inode !=
 681                                             cpu_to_le32(inode->i_ino))
 682                                                 goto not_empty;
 683                                 } else if (de->name[1] != '.')
 684                                         goto not_empty;
 685                         }
 686                         de = ext2_next_entry(de);
 687                 }
 688                 ext2_put_page(page);
 689         }
 690         return 1;
 691
 692 not_empty:
 693         ext2_put_page(page);
 694         return 0;
 695 }
 696
 697 struct file_operations ll_dir_operations = {
 698         read: generic_read_dir,
 699         readdir: new_ll_readdir
 700 };