?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / fs / nilfs2 / dir.c
blobcb003c8ee1f6d9f839bd78f2a3c182086d629645
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 };
Tomato firmware and modifications.