2 * dir.c - NILFS directory entry operations
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
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.
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.
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
20 * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>
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)
32 * linux/fs/minix/dir.c
34 * Copyright (C) 1991, 1992 Linus Torvalds
36 * ext2 directory handling functions
38 * Big-endian to little-endian byte-swapping/bitmaps by
39 * David S. Miller (davem@caip.rutgers.edu), 1995
41 * All code that works with directory layout had been switched to pagecache
45 #include <linux/pagemap.h>
50 * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
51 * more robust, but we have what we have
53 static inline unsigned nilfs_chunk_size(struct inode
*inode
)
55 return inode
->i_sb
->s_blocksize
;
58 static inline void nilfs_put_page(struct page
*page
)
61 page_cache_release(page
);
64 static inline unsigned long dir_pages(struct inode
*inode
)
66 return (inode
->i_size
+PAGE_CACHE_SIZE
-1)>>PAGE_CACHE_SHIFT
;
70 * Return the offset into page `page_nr' of the last valid
71 * byte in that page, plus one.
73 static unsigned nilfs_last_byte(struct inode
*inode
, unsigned long page_nr
)
75 unsigned last_byte
= inode
->i_size
;
77 last_byte
-= page_nr
<< PAGE_CACHE_SHIFT
;
78 if (last_byte
> PAGE_CACHE_SIZE
)
79 last_byte
= PAGE_CACHE_SIZE
;
83 static int nilfs_prepare_chunk_uninterruptible(struct page
*page
,
84 struct address_space
*mapping
,
85 unsigned from
, unsigned to
)
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
);
93 static int nilfs_prepare_chunk(struct page
*page
,
94 struct address_space
*mapping
,
95 unsigned from
, unsigned to
)
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
);
102 static void nilfs_commit_chunk(struct page
*page
,
103 struct address_space
*mapping
,
104 unsigned from
, unsigned to
)
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
;
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
);
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 */
124 static void nilfs_check_page(struct page
*page
)
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
;
135 if ((dir
->i_size
>> PAGE_CACHE_SHIFT
) == page
->index
) {
136 limit
= dir
->i_size
& ~PAGE_CACHE_MASK
;
137 if (limit
& (chunk_size
- 1))
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
);
146 if (rec_len
< NILFS_DIR_REC_LEN(1))
150 if (rec_len
< NILFS_DIR_REC_LEN(p
->name_len
))
152 if (((offs
+ rec_len
- 1) ^ offs
) & ~(chunk_size
-1))
158 SetPageChecked(page
);
161 /* Too bad, we had an error */
164 nilfs_error(sb
, "nilfs_check_page",
165 "size of directory #%lu is not a multiple of chunk size",
170 error
= "rec_len is smaller than minimal";
173 error
= "unaligned directory entry";
176 error
= "rec_len is too small for name_len";
179 error
= "directory entry across blocks";
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
);
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
));
195 SetPageChecked(page
);
199 static struct page
*nilfs_get_page(struct inode
*dir
, unsigned long n
)
201 struct address_space
*mapping
= dir
->i_mapping
;
202 struct page
*page
= read_mapping_page(mapping
, n
, NULL
);
206 if (!PageChecked(page
))
207 nilfs_check_page(page
);
214 nilfs_put_page(page
);
215 return ERR_PTR(-EIO
);
219 * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
221 * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
224 nilfs_match(int len
, const unsigned char *name
, struct nilfs_dir_entry
*de
)
226 if (len
!= de
->name_len
)
230 return !memcmp(name
, de
->name
, len
);
234 * p is at least 6 bytes before the end of page
236 static struct nilfs_dir_entry
*nilfs_next_entry(struct nilfs_dir_entry
*p
)
238 return (struct nilfs_dir_entry
*)((char *)p
+
239 nilfs_rec_len_from_disk(p
->rec_len
));
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
,
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
,
266 static void nilfs_set_de_type(struct nilfs_dir_entry
*de
, struct inode
*inode
)
268 mode_t mode
= inode
->i_mode
;
270 de
->file_type
= nilfs_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
273 static int nilfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
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
;
285 if (pos
> inode
->i_size
- NILFS_DIR_REC_LEN(1))
288 types
= nilfs_filetype_table
;
290 for ( ; n
< npages
; n
++, offset
= 0) {
292 struct nilfs_dir_entry
*de
;
293 struct page
*page
= nilfs_get_page(inode
, n
);
296 nilfs_error(sb
, __func__
, "bad page in #%lu",
298 filp
->f_pos
+= PAGE_CACHE_SIZE
- offset
;
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");
311 nilfs_put_page(page
);
316 unsigned char d_type
= DT_UNKNOWN
;
318 if (types
&& de
->file_type
< NILFS_FT_MAX
)
319 d_type
= types
[de
->file_type
];
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
);
326 nilfs_put_page(page
);
330 filp
->f_pos
+= nilfs_rec_len_from_disk(de
->rec_len
);
332 nilfs_put_page(page
);
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.
349 struct nilfs_dir_entry
*
350 nilfs_find_entry(struct inode
*dir
, const struct qstr
*qstr
,
351 struct page
**res_page
)
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
;
368 start
= ei
->i_dir_start_lookup
;
374 page
= nilfs_get_page(dir
, n
);
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
);
386 if (nilfs_match(namelen
, name
, de
))
388 de
= nilfs_next_entry(de
);
390 nilfs_put_page(page
);
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
);
402 } while (n
!= start
);
408 ei
->i_dir_start_lookup
= n
;
412 struct nilfs_dir_entry
*nilfs_dotdot(struct inode
*dir
, struct page
**p
)
414 struct page
*page
= nilfs_get_page(dir
, 0);
415 struct nilfs_dir_entry
*de
= NULL
;
418 de
= nilfs_next_entry(
419 (struct nilfs_dir_entry
*)page_address(page
));
425 ino_t
nilfs_inode_by_name(struct inode
*dir
, const struct qstr
*qstr
)
428 struct nilfs_dir_entry
*de
;
431 de
= nilfs_find_entry(dir
, qstr
, &page
);
433 res
= le64_to_cpu(de
->inode
);
435 page_cache_release(page
);
440 /* Releases the page */
441 void nilfs_set_link(struct inode
*dir
, struct nilfs_dir_entry
*de
,
442 struct page
*page
, struct inode
*inode
)
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
;
450 err
= nilfs_prepare_chunk_uninterruptible(page
, mapping
, from
, to
);
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; */
463 int nilfs_add_link(struct dentry
*dentry
, struct inode
*inode
)
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
);
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.
484 for (n
= 0; n
<= npages
; n
++) {
487 page
= nilfs_get_page(dir
, n
);
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
) {
500 rec_len
= chunk_size
;
501 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
);
505 if (de
->rec_len
== 0) {
506 nilfs_error(dir
->i_sb
, __func__
,
507 "zero-length directory entry");
512 if (nilfs_match(namelen
, name
, de
))
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
)
518 if (rec_len
>= name_len
+ reclen
)
520 de
= (struct nilfs_dir_entry
*)((char *)de
+ rec_len
);
523 nilfs_put_page(page
);
529 from
= (char *)de
- (char *)page_address(page
);
531 err
= nilfs_prepare_chunk(page
, page
->mapping
, from
, to
);
535 struct nilfs_dir_entry
*de1
;
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
);
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
);
552 nilfs_put_page(page
);
561 * nilfs_delete_entry deletes a directory entry by merging it with the
562 * previous entry. Page is up-to-date. Releases the page.
564 int nilfs_delete_entry(struct nilfs_dir_entry
*dir
, struct page
*page
)
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
);
576 while ((char *)de
< (char *)dir
) {
577 if (de
->rec_len
== 0) {
578 nilfs_error(inode
->i_sb
, __func__
,
579 "zero-length directory entry");
584 de
= nilfs_next_entry(de
);
587 from
= (char *)pde
- (char *)page_address(page
);
589 err
= nilfs_prepare_chunk(page
, mapping
, from
, to
);
592 pde
->rec_len
= nilfs_rec_len_to_disk(to
- from
);
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; */
598 nilfs_put_page(page
);
603 * Set the first fragment of directory.
605 int nilfs_make_empty(struct inode
*inode
, struct inode
*parent
)
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
;
617 err
= nilfs_prepare_chunk(page
, mapping
, 0, chunk_size
);
622 kaddr
= kmap_atomic(page
, KM_USER0
);
623 memset(kaddr
, 0, chunk_size
);
624 de
= (struct nilfs_dir_entry
*)kaddr
;
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
);
631 de
= (struct nilfs_dir_entry
*)(kaddr
+ NILFS_DIR_REC_LEN(1));
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
);
640 page_cache_release(page
);
645 * routine to check that the specified directory is empty (for rmdir)
647 int nilfs_empty_dir(struct inode
*inode
)
649 struct page
*page
= NULL
;
650 unsigned long i
, npages
= dir_pages(inode
);
652 for (i
= 0; i
< npages
; i
++) {
654 struct nilfs_dir_entry
*de
;
656 page
= nilfs_get_page(inode
, i
);
660 kaddr
= page_address(page
);
661 de
= (struct nilfs_dir_entry
*)kaddr
;
662 kaddr
+= nilfs_last_byte(inode
, i
) - NILFS_DIR_REC_LEN(1);
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
);
671 if (de
->inode
!= 0) {
672 /* check for . and .. */
673 if (de
->name
[0] != '.')
675 if (de
->name_len
> 2)
677 if (de
->name_len
< 2) {
679 cpu_to_le64(inode
->i_ino
))
681 } else if (de
->name
[1] != '.')
684 de
= nilfs_next_entry(de
);
686 nilfs_put_page(page
);
691 nilfs_put_page(page
);
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
,
701 .compat_ioctl
= nilfs_ioctl
,
702 #endif /* CONFIG_COMPAT */
703 .fsync
= nilfs_sync_file
,