lustre/llite/dir.c

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