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