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