fs/nilfs2/dir.c

   1 /*
   2  * dir.c - NILFS directory entry operations
   3  *
   4  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * Modified for NILFS by Amagai Yoshiji.
  17  */
  18 /*
  19  *  linux/fs/ext2/dir.c
  20  *
  21  * Copyright (C) 1992, 1993, 1994, 1995
  22  * Remy Card (card@masi.ibp.fr)
  23  * Laboratoire MASI - Institut Blaise Pascal
  24  * Universite Pierre et Marie Curie (Paris VI)
  25  *
  26  *  from
  27  *
  28  *  linux/fs/minix/dir.c
  29  *
  30  *  Copyright (C) 1991, 1992  Linus Torvalds
  31  *
  32  *  ext2 directory handling functions
  33  *
  34  *  Big-endian to little-endian byte-swapping/bitmaps by
  35  *        David S. Miller (davem@caip.rutgers.edu), 1995
  36  *
  37  * All code that works with directory layout had been switched to pagecache
  38  * and moved here. AV
  39  */
  40
  41 #include <linux/pagemap.h>
  42 #include "nilfs.h"
  43 #include "page.h"
  44
  45 /*
  46  * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
  47  * more robust, but we have what we have
  48  */
  49 static inline unsigned nilfs_chunk_size(struct inode *inode)
  50 {
  51         return inode->i_sb->s_blocksize;
  52 }
  53
  54 static inline void nilfs_put_page(struct page *page)
  55 {
  56         kunmap(page);
  57         put_page(page);
  58 }
  59
  60 /*
  61  * Return the offset into page `page_nr' of the last valid
  62  * byte in that page, plus one.
  63  */
  64 static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
  65 {
  66         unsigned last_byte = inode->i_size;
  67
  68         last_byte -= page_nr << PAGE_SHIFT;
  69         if (last_byte > PAGE_SIZE)
  70                 last_byte = PAGE_SIZE;
  71         return last_byte;
  72 }
  73
  74 static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
  75 {
  76         loff_t pos = page_offset(page) + from;
  77
  78         return __block_write_begin(page, pos, to - from, nilfs_get_block);
  79 }
  80
  81 static void nilfs_commit_chunk(struct page *page,
  82                                struct address_space *mapping,
  83                                unsigned from, unsigned to)
  84 {
  85         struct inode *dir = mapping->host;
  86         loff_t pos = page_offset(page) + from;
  87         unsigned len = to - from;
  88         unsigned nr_dirty, copied;
  89         int err;
  90
  91         nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
  92         copied = block_write_end(NULL, mapping, pos, len, len, page, NULL);
  93         if (pos + copied > dir->i_size)
  94                 i_size_write(dir, pos + copied);
  95         if (IS_DIRSYNC(dir))
  96                 nilfs_set_transaction_flag(NILFS_TI_SYNC);
  97         err = nilfs_set_file_dirty(dir, nr_dirty);
  98         WARN_ON(err); /* do not happen */
  99         unlock_page(page);
 100 }
 101
 102 static bool nilfs_check_page(struct page *page)
 103 {
 104         struct inode *dir = page->mapping->host;
 105         struct super_block *sb = dir->i_sb;
 106         unsigned chunk_size = nilfs_chunk_size(dir);
 107         char *kaddr = page_address(page);
 108         unsigned offs, rec_len;
 109         unsigned limit = PAGE_SIZE;
 110         struct nilfs_dir_entry *p;
 111         char *error;
 112
 113         if ((dir->i_size >> PAGE_SHIFT) == page->index) {
 114                 limit = dir->i_size & ~PAGE_MASK;
 115                 if (limit & (chunk_size - 1))
 116                         goto Ebadsize;
 117                 if (!limit)
 118                         goto out;
 119         }
 120         for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) {
 121                 p = (struct nilfs_dir_entry *)(kaddr + offs);
 122                 rec_len = nilfs_rec_len_from_disk(p->rec_len);
 123
 124                 if (rec_len < NILFS_DIR_REC_LEN(1))
 125                         goto Eshort;
 126                 if (rec_len & 3)
 127                         goto Ealign;
 128                 if (rec_len < NILFS_DIR_REC_LEN(p->name_len))
 129                         goto Enamelen;
 130                 if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
 131                         goto Espan;
 132         }
 133         if (offs != limit)
 134                 goto Eend;
 135 out:
 136         SetPageChecked(page);
 137         return true;
 138
 139         /* Too bad, we had an error */
 140
 141 Ebadsize:
 142         nilfs_error(sb, "nilfs_check_page",
 143                     "size of directory #%lu is not a multiple of chunk size",
 144                     dir->i_ino
 145         );
 146         goto fail;
 147 Eshort:
 148         error = "rec_len is smaller than minimal";
 149         goto bad_entry;
 150 Ealign:
 151         error = "unaligned directory entry";
 152         goto bad_entry;
 153 Enamelen:
 154         error = "rec_len is too small for name_len";
 155         goto bad_entry;
 156 Espan:
 157         error = "directory entry across blocks";
 158 bad_entry:
 159         nilfs_error(sb, "nilfs_check_page", "bad entry in directory #%lu: %s - "
 160                     "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
 161                     dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs,
 162                     (unsigned long) le64_to_cpu(p->inode),
 163                     rec_len, p->name_len);
 164         goto fail;
 165 Eend:
 166         p = (struct nilfs_dir_entry *)(kaddr + offs);
 167         nilfs_error(sb, "nilfs_check_page",
 168                     "entry in directory #%lu spans the page boundary"
 169                     "offset=%lu, inode=%lu",
 170                     dir->i_ino, (page->index<<PAGE_SHIFT)+offs,
 171                     (unsigned long) le64_to_cpu(p->inode));
 172 fail:
 173         SetPageError(page);
 174         return false;
 175 }
 176
 177 static struct page *nilfs_get_page(struct inode *dir, unsigned long n)
 178 {
 179         struct address_space *mapping = dir->i_mapping;
 180         struct page *page = read_mapping_page(mapping, n, NULL);
 181
 182         if (!IS_ERR(page)) {
 183                 kmap(page);
 184                 if (unlikely(!PageChecked(page))) {
 185                         if (PageError(page) || !nilfs_check_page(page))
 186                                 goto fail;
 187                 }
 188         }
 189         return page;
 190
 191 fail:
 192         nilfs_put_page(page);
 193         return ERR_PTR(-EIO);
 194 }
 195
 196 /*
 197  * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
 198  *
 199  * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
 200  */
 201 static int
 202 nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de)
 203 {
 204         if (len != de->name_len)
 205                 return 0;
 206         if (!de->inode)
 207                 return 0;
 208         return !memcmp(name, de->name, len);
 209 }
 210
 211 /*
 212  * p is at least 6 bytes before the end of page
 213  */
 214 static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p)
 215 {
 216         return (struct nilfs_dir_entry *)((char *)p +
 217                                           nilfs_rec_len_from_disk(p->rec_len));
 218 }
 219
 220 static unsigned char
 221 nilfs_filetype_table[NILFS_FT_MAX] = {
 222         [NILFS_FT_UNKNOWN]      = DT_UNKNOWN,
 223         [NILFS_FT_REG_FILE]     = DT_REG,
 224         [NILFS_FT_DIR]          = DT_DIR,
 225         [NILFS_FT_CHRDEV]       = DT_CHR,
 226         [NILFS_FT_BLKDEV]       = DT_BLK,
 227         [NILFS_FT_FIFO]         = DT_FIFO,
 228         [NILFS_FT_SOCK]         = DT_SOCK,
 229         [NILFS_FT_SYMLINK]      = DT_LNK,
 230 };
 231
 232 #define S_SHIFT 12
 233 static unsigned char
 234 nilfs_type_by_mode[S_IFMT >> S_SHIFT] = {
 235         [S_IFREG >> S_SHIFT]    = NILFS_FT_REG_FILE,
 236         [S_IFDIR >> S_SHIFT]    = NILFS_FT_DIR,
 237         [S_IFCHR >> S_SHIFT]    = NILFS_FT_CHRDEV,
 238         [S_IFBLK >> S_SHIFT]    = NILFS_FT_BLKDEV,
 239         [S_IFIFO >> S_SHIFT]    = NILFS_FT_FIFO,
 240         [S_IFSOCK >> S_SHIFT]   = NILFS_FT_SOCK,
 241         [S_IFLNK >> S_SHIFT]    = NILFS_FT_SYMLINK,
 242 };
 243
 244 static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
 245 {
 246         umode_t mode = inode->i_mode;
 247
 248         de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
 249 }
 250
 251 static int nilfs_readdir(struct file *file, struct dir_context *ctx)
 252 {
 253         loff_t pos = ctx->pos;
 254         struct inode *inode = file_inode(file);
 255         struct super_block *sb = inode->i_sb;
 256         unsigned int offset = pos & ~PAGE_MASK;
 257         unsigned long n = pos >> PAGE_SHIFT;
 258         unsigned long npages = dir_pages(inode);
 259 /*      unsigned chunk_mask = ~(nilfs_chunk_size(inode)-1); */
 260
 261         if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
 262                 return 0;
 263
 264         for ( ; n < npages; n++, offset = 0) {
 265                 char *kaddr, *limit;
 266                 struct nilfs_dir_entry *de;
 267                 struct page *page = nilfs_get_page(inode, n);
 268
 269                 if (IS_ERR(page)) {
 270                         nilfs_error(sb, __func__, "bad page in #%lu",
 271                                     inode->i_ino);
 272                         ctx->pos += PAGE_SIZE - offset;
 273                         return -EIO;
 274                 }
 275                 kaddr = page_address(page);
 276                 de = (struct nilfs_dir_entry *)(kaddr + offset);
 277                 limit = kaddr + nilfs_last_byte(inode, n) -
 278                         NILFS_DIR_REC_LEN(1);
 279                 for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {
 280                         if (de->rec_len == 0) {
 281                                 nilfs_error(sb, __func__,
 282                                             "zero-length directory entry");
 283                                 nilfs_put_page(page);
 284                                 return -EIO;
 285                         }
 286                         if (de->inode) {
 287                                 unsigned char t;
 288
 289                                 if (de->file_type < NILFS_FT_MAX)
 290                                         t = nilfs_filetype_table[de->file_type];
 291                                 else
 292                                         t = DT_UNKNOWN;
 293
 294                                 if (!dir_emit(ctx, de->name, de->name_len,
 295                                                 le64_to_cpu(de->inode), t)) {
 296                                         nilfs_put_page(page);
 297                                         return 0;
 298                                 }
 299                         }
 300                         ctx->pos += nilfs_rec_len_from_disk(de->rec_len);
 301                 }
 302                 nilfs_put_page(page);
 303         }
 304         return 0;
 305 }
 306
 307 /*
 308  *      nilfs_find_entry()
 309  *
 310  * finds an entry in the specified directory with the wanted name. It
 311  * returns the page in which the entry was found, and the entry itself
 312  * (as a parameter - res_dir). Page is returned mapped and unlocked.
 313  * Entry is guaranteed to be valid.
 314  */
 315 struct nilfs_dir_entry *
 316 nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
 317                  struct page **res_page)
 318 {
 319         const unsigned char *name = qstr->name;
 320         int namelen = qstr->len;
 321         unsigned reclen = NILFS_DIR_REC_LEN(namelen);
 322         unsigned long start, n;
 323         unsigned long npages = dir_pages(dir);
 324         struct page *page = NULL;
 325         struct nilfs_inode_info *ei = NILFS_I(dir);
 326         struct nilfs_dir_entry *de;
 327
 328         if (npages == 0)
 329                 goto out;
 330
 331         /* OFFSET_CACHE */
 332         *res_page = NULL;
 333
 334         start = ei->i_dir_start_lookup;
 335         if (start >= npages)
 336                 start = 0;
 337         n = start;
 338         do {
 339                 char *kaddr;
 340
 341                 page = nilfs_get_page(dir, n);
 342                 if (!IS_ERR(page)) {
 343                         kaddr = page_address(page);
 344                         de = (struct nilfs_dir_entry *)kaddr;
 345                         kaddr += nilfs_last_byte(dir, n) - reclen;
 346                         while ((char *) de <= kaddr) {
 347                                 if (de->rec_len == 0) {
 348                                         nilfs_error(dir->i_sb, __func__,
 349                                                 "zero-length directory entry");
 350                                         nilfs_put_page(page);
 351                                         goto out;
 352                                 }
 353                                 if (nilfs_match(namelen, name, de))
 354                                         goto found;
 355                                 de = nilfs_next_entry(de);
 356                         }
 357                         nilfs_put_page(page);
 358                 }
 359                 if (++n >= npages)
 360                         n = 0;
 361                 /* next page is past the blocks we've got */
 362                 if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
 363                         nilfs_error(dir->i_sb, __func__,
 364                                "dir %lu size %lld exceeds block count %llu",
 365                                dir->i_ino, dir->i_size,
 366                                (unsigned long long)dir->i_blocks);
 367                         goto out;
 368                 }
 369         } while (n != start);
 370 out:
 371         return NULL;
 372
 373 found:
 374         *res_page = page;
 375         ei->i_dir_start_lookup = n;
 376         return de;
 377 }
 378
 379 struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p)
 380 {
 381         struct page *page = nilfs_get_page(dir, 0);
 382         struct nilfs_dir_entry *de = NULL;
 383
 384         if (!IS_ERR(page)) {
 385                 de = nilfs_next_entry(
 386                         (struct nilfs_dir_entry *)page_address(page));
 387                 *p = page;
 388         }
 389         return de;
 390 }
 391
 392 ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr)
 393 {
 394         ino_t res = 0;
 395         struct nilfs_dir_entry *de;
 396         struct page *page;
 397
 398         de = nilfs_find_entry(dir, qstr, &page);
 399         if (de) {
 400                 res = le64_to_cpu(de->inode);
 401                 kunmap(page);
 402                 put_page(page);
 403         }
 404         return res;
 405 }
 406
 407 /* Releases the page */
 408 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
 409                     struct page *page, struct inode *inode)
 410 {
 411         unsigned from = (char *) de - (char *) page_address(page);
 412         unsigned to = from + nilfs_rec_len_from_disk(de->rec_len);
 413         struct address_space *mapping = page->mapping;
 414         int err;
 415
 416         lock_page(page);
 417         err = nilfs_prepare_chunk(page, from, to);
 418         BUG_ON(err);
 419         de->inode = cpu_to_le64(inode->i_ino);
 420         nilfs_set_de_type(de, inode);
 421         nilfs_commit_chunk(page, mapping, from, to);
 422         nilfs_put_page(page);
 423         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 424 }
 425
 426 /*
 427  *      Parent is locked.
 428  */
 429 int nilfs_add_link(struct dentry *dentry, struct inode *inode)
 430 {
 431         struct inode *dir = d_inode(dentry->d_parent);
 432         const unsigned char *name = dentry->d_name.name;
 433         int namelen = dentry->d_name.len;
 434         unsigned chunk_size = nilfs_chunk_size(dir);
 435         unsigned reclen = NILFS_DIR_REC_LEN(namelen);
 436         unsigned short rec_len, name_len;
 437         struct page *page = NULL;
 438         struct nilfs_dir_entry *de;
 439         unsigned long npages = dir_pages(dir);
 440         unsigned long n;
 441         char *kaddr;
 442         unsigned from, to;
 443         int err;
 444
 445         /*
 446          * We take care of directory expansion in the same loop.
 447          * This code plays outside i_size, so it locks the page
 448          * to protect that region.
 449          */
 450         for (n = 0; n <= npages; n++) {
 451                 char *dir_end;
 452
 453                 page = nilfs_get_page(dir, n);
 454                 err = PTR_ERR(page);
 455                 if (IS_ERR(page))
 456                         goto out;
 457                 lock_page(page);
 458                 kaddr = page_address(page);
 459                 dir_end = kaddr + nilfs_last_byte(dir, n);
 460                 de = (struct nilfs_dir_entry *)kaddr;
 461                 kaddr += PAGE_SIZE - reclen;
 462                 while ((char *)de <= kaddr) {
 463                         if ((char *)de == dir_end) {
 464                                 /* We hit i_size */
 465                                 name_len = 0;
 466                                 rec_len = chunk_size;
 467                                 de->rec_len = nilfs_rec_len_to_disk(chunk_size);
 468                                 de->inode = 0;
 469                                 goto got_it;
 470                         }
 471                         if (de->rec_len == 0) {
 472                                 nilfs_error(dir->i_sb, __func__,
 473                                             "zero-length directory entry");
 474                                 err = -EIO;
 475                                 goto out_unlock;
 476                         }
 477                         err = -EEXIST;
 478                         if (nilfs_match(namelen, name, de))
 479                                 goto out_unlock;
 480                         name_len = NILFS_DIR_REC_LEN(de->name_len);
 481                         rec_len = nilfs_rec_len_from_disk(de->rec_len);
 482                         if (!de->inode && rec_len >= reclen)
 483                                 goto got_it;
 484                         if (rec_len >= name_len + reclen)
 485                                 goto got_it;
 486                         de = (struct nilfs_dir_entry *)((char *)de + rec_len);
 487                 }
 488                 unlock_page(page);
 489                 nilfs_put_page(page);
 490         }
 491         BUG();
 492         return -EINVAL;
 493
 494 got_it:
 495         from = (char *)de - (char *)page_address(page);
 496         to = from + rec_len;
 497         err = nilfs_prepare_chunk(page, from, to);
 498         if (err)
 499                 goto out_unlock;
 500         if (de->inode) {
 501                 struct nilfs_dir_entry *de1;
 502
 503                 de1 = (struct nilfs_dir_entry *)((char *)de + name_len);
 504                 de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len);
 505                 de->rec_len = nilfs_rec_len_to_disk(name_len);
 506                 de = de1;
 507         }
 508         de->name_len = namelen;
 509         memcpy(de->name, name, namelen);
 510         de->inode = cpu_to_le64(inode->i_ino);
 511         nilfs_set_de_type(de, inode);
 512         nilfs_commit_chunk(page, page->mapping, from, to);
 513         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 514         nilfs_mark_inode_dirty(dir);
 515         /* OFFSET_CACHE */
 516 out_put:
 517         nilfs_put_page(page);
 518 out:
 519         return err;
 520 out_unlock:
 521         unlock_page(page);
 522         goto out_put;
 523 }
 524
 525 /*
 526  * nilfs_delete_entry deletes a directory entry by merging it with the
 527  * previous entry. Page is up-to-date. Releases the page.
 528  */
 529 int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
 530 {
 531         struct address_space *mapping = page->mapping;
 532         struct inode *inode = mapping->host;
 533         char *kaddr = page_address(page);
 534         unsigned from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
 535         unsigned to = ((char *)dir - kaddr) +
 536                 nilfs_rec_len_from_disk(dir->rec_len);
 537         struct nilfs_dir_entry *pde = NULL;
 538         struct nilfs_dir_entry *de = (struct nilfs_dir_entry *)(kaddr + from);
 539         int err;
 540
 541         while ((char *)de < (char *)dir) {
 542                 if (de->rec_len == 0) {
 543                         nilfs_error(inode->i_sb, __func__,
 544                                     "zero-length directory entry");
 545                         err = -EIO;
 546                         goto out;
 547                 }
 548                 pde = de;
 549                 de = nilfs_next_entry(de);
 550         }
 551         if (pde)
 552                 from = (char *)pde - (char *)page_address(page);
 553         lock_page(page);
 554         err = nilfs_prepare_chunk(page, from, to);
 555         BUG_ON(err);
 556         if (pde)
 557                 pde->rec_len = nilfs_rec_len_to_disk(to - from);
 558         dir->inode = 0;
 559         nilfs_commit_chunk(page, mapping, from, to);
 560         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 561 out:
 562         nilfs_put_page(page);
 563         return err;
 564 }
 565
 566 /*
 567  * Set the first fragment of directory.
 568  */
 569 int nilfs_make_empty(struct inode *inode, struct inode *parent)
 570 {
 571         struct address_space *mapping = inode->i_mapping;
 572         struct page *page = grab_cache_page(mapping, 0);
 573         unsigned chunk_size = nilfs_chunk_size(inode);
 574         struct nilfs_dir_entry *de;
 575         int err;
 576         void *kaddr;
 577
 578         if (!page)
 579                 return -ENOMEM;
 580
 581         err = nilfs_prepare_chunk(page, 0, chunk_size);
 582         if (unlikely(err)) {
 583                 unlock_page(page);
 584                 goto fail;
 585         }
 586         kaddr = kmap_atomic(page);
 587         memset(kaddr, 0, chunk_size);
 588         de = (struct nilfs_dir_entry *)kaddr;
 589         de->name_len = 1;
 590         de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
 591         memcpy(de->name, ".\0\0", 4);
 592         de->inode = cpu_to_le64(inode->i_ino);
 593         nilfs_set_de_type(de, inode);
 594
 595         de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1));
 596         de->name_len = 2;
 597         de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1));
 598         de->inode = cpu_to_le64(parent->i_ino);
 599         memcpy(de->name, "..\0", 4);
 600         nilfs_set_de_type(de, inode);
 601         kunmap_atomic(kaddr);
 602         nilfs_commit_chunk(page, mapping, 0, chunk_size);
 603 fail:
 604         put_page(page);
 605         return err;
 606 }
 607
 608 /*
 609  * routine to check that the specified directory is empty (for rmdir)
 610  */
 611 int nilfs_empty_dir(struct inode *inode)
 612 {
 613         struct page *page = NULL;
 614         unsigned long i, npages = dir_pages(inode);
 615
 616         for (i = 0; i < npages; i++) {
 617                 char *kaddr;
 618                 struct nilfs_dir_entry *de;
 619
 620                 page = nilfs_get_page(inode, i);
 621                 if (IS_ERR(page))
 622                         continue;
 623
 624                 kaddr = page_address(page);
 625                 de = (struct nilfs_dir_entry *)kaddr;
 626                 kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1);
 627
 628                 while ((char *)de <= kaddr) {
 629                         if (de->rec_len == 0) {
 630                                 nilfs_error(inode->i_sb, __func__,
 631                                             "zero-length directory entry "
 632                                             "(kaddr=%p, de=%p)\n", kaddr, de);
 633                                 goto not_empty;
 634                         }
 635                         if (de->inode != 0) {
 636                                 /* check for . and .. */
 637                                 if (de->name[0] != '.')
 638                                         goto not_empty;
 639                                 if (de->name_len > 2)
 640                                         goto not_empty;
 641                                 if (de->name_len < 2) {
 642                                         if (de->inode !=
 643                                             cpu_to_le64(inode->i_ino))
 644                                                 goto not_empty;
 645                                 } else if (de->name[1] != '.')
 646                                         goto not_empty;
 647                         }
 648                         de = nilfs_next_entry(de);
 649                 }
 650                 nilfs_put_page(page);
 651         }
 652         return 1;
 653
 654 not_empty:
 655         nilfs_put_page(page);
 656         return 0;
 657 }
 658
 659 const struct file_operations nilfs_dir_operations = {
 660         .llseek         = generic_file_llseek,
 661         .read           = generic_read_dir,
 662         .iterate_shared = nilfs_readdir,
 663         .unlocked_ioctl = nilfs_ioctl,
 664 #ifdef CONFIG_COMPAT
 665         .compat_ioctl   = nilfs_compat_ioctl,
 666 #endif  /* CONFIG_COMPAT */
 667         .fsync          = nilfs_sync_file,
 668
 669 };