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