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 * Modified for NILFS by Amagai Yoshiji.
21 * Copyright (C) 1992, 1993, 1994, 1995
22 * Remy Card (card@masi.ibp.fr)
23 * Laboratoire MASI - Institut Blaise Pascal
24 * Universite Pierre et Marie Curie (Paris VI)
28 * linux/fs/minix/dir.c
30 * Copyright (C) 1991, 1992 Linus Torvalds
32 * ext2 directory handling functions
34 * Big-endian to little-endian byte-swapping/bitmaps by
35 * David S. Miller (davem@caip.rutgers.edu), 1995
37 * All code that works with directory layout had been switched to pagecache
41 #include <linux/pagemap.h>
46 * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
47 * more robust, but we have what we have
49 static inline unsigned int nilfs_chunk_size(struct inode
*inode
)
51 return inode
->i_sb
->s_blocksize
;
54 static inline void nilfs_put_page(struct page
*page
)
61 * Return the offset into page `page_nr' of the last valid
62 * byte in that page, plus one.
64 static unsigned int nilfs_last_byte(struct inode
*inode
, unsigned long page_nr
)
66 unsigned int last_byte
= inode
->i_size
;
68 last_byte
-= page_nr
<< PAGE_SHIFT
;
69 if (last_byte
> PAGE_SIZE
)
70 last_byte
= PAGE_SIZE
;
74 static int nilfs_prepare_chunk(struct page
*page
, unsigned int from
,
77 loff_t pos
= page_offset(page
) + from
;
79 return __block_write_begin(page
, pos
, to
- from
, nilfs_get_block
);
82 static void nilfs_commit_chunk(struct page
*page
,
83 struct address_space
*mapping
,
84 unsigned int from
, unsigned int to
)
86 struct inode
*dir
= mapping
->host
;
87 loff_t pos
= page_offset(page
) + from
;
88 unsigned int len
= to
- from
;
89 unsigned int nr_dirty
, copied
;
92 nr_dirty
= nilfs_page_count_clean_buffers(page
, from
, to
);
93 copied
= block_write_end(NULL
, mapping
, pos
, len
, len
, page
, NULL
);
94 if (pos
+ copied
> dir
->i_size
)
95 i_size_write(dir
, pos
+ copied
);
97 nilfs_set_transaction_flag(NILFS_TI_SYNC
);
98 err
= nilfs_set_file_dirty(dir
, nr_dirty
);
99 WARN_ON(err
); /* do not happen */
103 static bool nilfs_check_page(struct page
*page
)
105 struct inode
*dir
= page
->mapping
->host
;
106 struct super_block
*sb
= dir
->i_sb
;
107 unsigned int chunk_size
= nilfs_chunk_size(dir
);
108 char *kaddr
= page_address(page
);
109 unsigned int offs
, rec_len
;
110 unsigned int limit
= PAGE_SIZE
;
111 struct nilfs_dir_entry
*p
;
114 if ((dir
->i_size
>> PAGE_SHIFT
) == page
->index
) {
115 limit
= dir
->i_size
& ~PAGE_MASK
;
116 if (limit
& (chunk_size
- 1))
121 for (offs
= 0; offs
<= limit
- NILFS_DIR_REC_LEN(1); offs
+= rec_len
) {
122 p
= (struct nilfs_dir_entry
*)(kaddr
+ offs
);
123 rec_len
= nilfs_rec_len_from_disk(p
->rec_len
);
125 if (rec_len
< NILFS_DIR_REC_LEN(1))
129 if (rec_len
< NILFS_DIR_REC_LEN(p
->name_len
))
131 if (((offs
+ rec_len
- 1) ^ offs
) & ~(chunk_size
-1))
137 SetPageChecked(page
);
140 /* Too bad, we had an error */
143 nilfs_error(sb
, "nilfs_check_page",
144 "size of directory #%lu is not a multiple of chunk size",
149 error
= "rec_len is smaller than minimal";
152 error
= "unaligned directory entry";
155 error
= "rec_len is too small for name_len";
158 error
= "directory entry across blocks";
160 nilfs_error(sb
, "nilfs_check_page", "bad entry in directory #%lu: %s - "
161 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
162 dir
->i_ino
, error
, (page
->index
<<PAGE_SHIFT
)+offs
,
163 (unsigned long) le64_to_cpu(p
->inode
),
164 rec_len
, p
->name_len
);
167 p
= (struct nilfs_dir_entry
*)(kaddr
+ offs
);
168 nilfs_error(sb
, "nilfs_check_page",
169 "entry in directory #%lu spans the page boundary"
170 "offset=%lu, inode=%lu",
171 dir
->i_ino
, (page
->index
<<PAGE_SHIFT
)+offs
,
172 (unsigned long) le64_to_cpu(p
->inode
));
178 static struct page
*nilfs_get_page(struct inode
*dir
, unsigned long n
)
180 struct address_space
*mapping
= dir
->i_mapping
;
181 struct page
*page
= read_mapping_page(mapping
, n
, NULL
);
185 if (unlikely(!PageChecked(page
))) {
186 if (PageError(page
) || !nilfs_check_page(page
))
193 nilfs_put_page(page
);
194 return ERR_PTR(-EIO
);
198 * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
200 * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
203 nilfs_match(int len
, const unsigned char *name
, struct nilfs_dir_entry
*de
)
205 if (len
!= de
->name_len
)
209 return !memcmp(name
, de
->name
, len
);
213 * p is at least 6 bytes before the end of page
215 static struct nilfs_dir_entry
*nilfs_next_entry(struct nilfs_dir_entry
*p
)
217 return (struct nilfs_dir_entry
*)((char *)p
+
218 nilfs_rec_len_from_disk(p
->rec_len
));
222 nilfs_filetype_table
[NILFS_FT_MAX
] = {
223 [NILFS_FT_UNKNOWN
] = DT_UNKNOWN
,
224 [NILFS_FT_REG_FILE
] = DT_REG
,
225 [NILFS_FT_DIR
] = DT_DIR
,
226 [NILFS_FT_CHRDEV
] = DT_CHR
,
227 [NILFS_FT_BLKDEV
] = DT_BLK
,
228 [NILFS_FT_FIFO
] = DT_FIFO
,
229 [NILFS_FT_SOCK
] = DT_SOCK
,
230 [NILFS_FT_SYMLINK
] = DT_LNK
,
235 nilfs_type_by_mode
[S_IFMT
>> S_SHIFT
] = {
236 [S_IFREG
>> S_SHIFT
] = NILFS_FT_REG_FILE
,
237 [S_IFDIR
>> S_SHIFT
] = NILFS_FT_DIR
,
238 [S_IFCHR
>> S_SHIFT
] = NILFS_FT_CHRDEV
,
239 [S_IFBLK
>> S_SHIFT
] = NILFS_FT_BLKDEV
,
240 [S_IFIFO
>> S_SHIFT
] = NILFS_FT_FIFO
,
241 [S_IFSOCK
>> S_SHIFT
] = NILFS_FT_SOCK
,
242 [S_IFLNK
>> S_SHIFT
] = NILFS_FT_SYMLINK
,
245 static void nilfs_set_de_type(struct nilfs_dir_entry
*de
, struct inode
*inode
)
247 umode_t mode
= inode
->i_mode
;
249 de
->file_type
= nilfs_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
252 static int nilfs_readdir(struct file
*file
, struct dir_context
*ctx
)
254 loff_t pos
= ctx
->pos
;
255 struct inode
*inode
= file_inode(file
);
256 struct super_block
*sb
= inode
->i_sb
;
257 unsigned int offset
= pos
& ~PAGE_MASK
;
258 unsigned long n
= pos
>> PAGE_SHIFT
;
259 unsigned long npages
= dir_pages(inode
);
261 if (pos
> inode
->i_size
- NILFS_DIR_REC_LEN(1))
264 for ( ; n
< npages
; n
++, offset
= 0) {
266 struct nilfs_dir_entry
*de
;
267 struct page
*page
= nilfs_get_page(inode
, n
);
270 nilfs_error(sb
, __func__
, "bad page in #%lu",
272 ctx
->pos
+= PAGE_SIZE
- offset
;
275 kaddr
= page_address(page
);
276 de
= (struct nilfs_dir_entry
*)(kaddr
+ offset
);
277 limit
= kaddr
+ nilfs_last_byte(inode
, n
) -
278 NILFS_DIR_REC_LEN(1);
279 for ( ; (char *)de
<= limit
; de
= nilfs_next_entry(de
)) {
280 if (de
->rec_len
== 0) {
281 nilfs_error(sb
, __func__
,
282 "zero-length directory entry");
283 nilfs_put_page(page
);
289 if (de
->file_type
< NILFS_FT_MAX
)
290 t
= nilfs_filetype_table
[de
->file_type
];
294 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
295 le64_to_cpu(de
->inode
), t
)) {
296 nilfs_put_page(page
);
300 ctx
->pos
+= nilfs_rec_len_from_disk(de
->rec_len
);
302 nilfs_put_page(page
);
310 * finds an entry in the specified directory with the wanted name. It
311 * returns the page in which the entry was found, and the entry itself
312 * (as a parameter - res_dir). Page is returned mapped and unlocked.
313 * Entry is guaranteed to be valid.
315 struct nilfs_dir_entry
*
316 nilfs_find_entry(struct inode
*dir
, const struct qstr
*qstr
,
317 struct page
**res_page
)
319 const unsigned char *name
= qstr
->name
;
320 int namelen
= qstr
->len
;
321 unsigned int reclen
= NILFS_DIR_REC_LEN(namelen
);
322 unsigned long start
, n
;
323 unsigned long npages
= dir_pages(dir
);
324 struct page
*page
= NULL
;
325 struct nilfs_inode_info
*ei
= NILFS_I(dir
);
326 struct nilfs_dir_entry
*de
;
334 start
= ei
->i_dir_start_lookup
;
341 page
= nilfs_get_page(dir
, n
);
343 kaddr
= page_address(page
);
344 de
= (struct nilfs_dir_entry
*)kaddr
;
345 kaddr
+= nilfs_last_byte(dir
, n
) - reclen
;
346 while ((char *) de
<= kaddr
) {
347 if (de
->rec_len
== 0) {
348 nilfs_error(dir
->i_sb
, __func__
,
349 "zero-length directory entry");
350 nilfs_put_page(page
);
353 if (nilfs_match(namelen
, name
, de
))
355 de
= nilfs_next_entry(de
);
357 nilfs_put_page(page
);
361 /* next page is past the blocks we've got */
362 if (unlikely(n
> (dir
->i_blocks
>> (PAGE_SHIFT
- 9)))) {
363 nilfs_error(dir
->i_sb
, __func__
,
364 "dir %lu size %lld exceeds block count %llu",
365 dir
->i_ino
, dir
->i_size
,
366 (unsigned long long)dir
->i_blocks
);
369 } while (n
!= start
);
375 ei
->i_dir_start_lookup
= n
;
379 struct nilfs_dir_entry
*nilfs_dotdot(struct inode
*dir
, struct page
**p
)
381 struct page
*page
= nilfs_get_page(dir
, 0);
382 struct nilfs_dir_entry
*de
= NULL
;
385 de
= nilfs_next_entry(
386 (struct nilfs_dir_entry
*)page_address(page
));
392 ino_t
nilfs_inode_by_name(struct inode
*dir
, const struct qstr
*qstr
)
395 struct nilfs_dir_entry
*de
;
398 de
= nilfs_find_entry(dir
, qstr
, &page
);
400 res
= le64_to_cpu(de
->inode
);
407 /* Releases the page */
408 void nilfs_set_link(struct inode
*dir
, struct nilfs_dir_entry
*de
,
409 struct page
*page
, struct inode
*inode
)
411 unsigned int from
= (char *)de
- (char *)page_address(page
);
412 unsigned int to
= from
+ nilfs_rec_len_from_disk(de
->rec_len
);
413 struct address_space
*mapping
= page
->mapping
;
417 err
= nilfs_prepare_chunk(page
, from
, to
);
419 de
->inode
= cpu_to_le64(inode
->i_ino
);
420 nilfs_set_de_type(de
, inode
);
421 nilfs_commit_chunk(page
, mapping
, from
, to
);
422 nilfs_put_page(page
);
423 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
429 int nilfs_add_link(struct dentry
*dentry
, struct inode
*inode
)
431 struct inode
*dir
= d_inode(dentry
->d_parent
);
432 const unsigned char *name
= dentry
->d_name
.name
;
433 int namelen
= dentry
->d_name
.len
;
434 unsigned int chunk_size
= nilfs_chunk_size(dir
);
435 unsigned int reclen
= NILFS_DIR_REC_LEN(namelen
);
436 unsigned short rec_len
, name_len
;
437 struct page
*page
= NULL
;
438 struct nilfs_dir_entry
*de
;
439 unsigned long npages
= dir_pages(dir
);
442 unsigned int from
, to
;
446 * We take care of directory expansion in the same loop.
447 * This code plays outside i_size, so it locks the page
448 * to protect that region.
450 for (n
= 0; n
<= npages
; n
++) {
453 page
= nilfs_get_page(dir
, n
);
458 kaddr
= page_address(page
);
459 dir_end
= kaddr
+ nilfs_last_byte(dir
, n
);
460 de
= (struct nilfs_dir_entry
*)kaddr
;
461 kaddr
+= PAGE_SIZE
- reclen
;
462 while ((char *)de
<= kaddr
) {
463 if ((char *)de
== dir_end
) {
466 rec_len
= chunk_size
;
467 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
);
471 if (de
->rec_len
== 0) {
472 nilfs_error(dir
->i_sb
, __func__
,
473 "zero-length directory entry");
478 if (nilfs_match(namelen
, name
, de
))
480 name_len
= NILFS_DIR_REC_LEN(de
->name_len
);
481 rec_len
= nilfs_rec_len_from_disk(de
->rec_len
);
482 if (!de
->inode
&& rec_len
>= reclen
)
484 if (rec_len
>= name_len
+ reclen
)
486 de
= (struct nilfs_dir_entry
*)((char *)de
+ rec_len
);
489 nilfs_put_page(page
);
495 from
= (char *)de
- (char *)page_address(page
);
497 err
= nilfs_prepare_chunk(page
, from
, to
);
501 struct nilfs_dir_entry
*de1
;
503 de1
= (struct nilfs_dir_entry
*)((char *)de
+ name_len
);
504 de1
->rec_len
= nilfs_rec_len_to_disk(rec_len
- name_len
);
505 de
->rec_len
= nilfs_rec_len_to_disk(name_len
);
508 de
->name_len
= namelen
;
509 memcpy(de
->name
, name
, namelen
);
510 de
->inode
= cpu_to_le64(inode
->i_ino
);
511 nilfs_set_de_type(de
, inode
);
512 nilfs_commit_chunk(page
, page
->mapping
, from
, to
);
513 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
514 nilfs_mark_inode_dirty(dir
);
517 nilfs_put_page(page
);
526 * nilfs_delete_entry deletes a directory entry by merging it with the
527 * previous entry. Page is up-to-date. Releases the page.
529 int nilfs_delete_entry(struct nilfs_dir_entry
*dir
, struct page
*page
)
531 struct address_space
*mapping
= page
->mapping
;
532 struct inode
*inode
= mapping
->host
;
533 char *kaddr
= page_address(page
);
534 unsigned int from
, to
;
535 struct nilfs_dir_entry
*de
, *pde
= NULL
;
538 from
= ((char *)dir
- kaddr
) & ~(nilfs_chunk_size(inode
) - 1);
539 to
= ((char *)dir
- kaddr
) + nilfs_rec_len_from_disk(dir
->rec_len
);
540 de
= (struct nilfs_dir_entry
*)(kaddr
+ from
);
542 while ((char *)de
< (char *)dir
) {
543 if (de
->rec_len
== 0) {
544 nilfs_error(inode
->i_sb
, __func__
,
545 "zero-length directory entry");
550 de
= nilfs_next_entry(de
);
553 from
= (char *)pde
- (char *)page_address(page
);
555 err
= nilfs_prepare_chunk(page
, from
, to
);
558 pde
->rec_len
= nilfs_rec_len_to_disk(to
- from
);
560 nilfs_commit_chunk(page
, mapping
, from
, to
);
561 inode
->i_ctime
= inode
->i_mtime
= CURRENT_TIME
;
563 nilfs_put_page(page
);
568 * Set the first fragment of directory.
570 int nilfs_make_empty(struct inode
*inode
, struct inode
*parent
)
572 struct address_space
*mapping
= inode
->i_mapping
;
573 struct page
*page
= grab_cache_page(mapping
, 0);
574 unsigned int chunk_size
= nilfs_chunk_size(inode
);
575 struct nilfs_dir_entry
*de
;
582 err
= nilfs_prepare_chunk(page
, 0, chunk_size
);
587 kaddr
= kmap_atomic(page
);
588 memset(kaddr
, 0, chunk_size
);
589 de
= (struct nilfs_dir_entry
*)kaddr
;
591 de
->rec_len
= nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
592 memcpy(de
->name
, ".\0\0", 4);
593 de
->inode
= cpu_to_le64(inode
->i_ino
);
594 nilfs_set_de_type(de
, inode
);
596 de
= (struct nilfs_dir_entry
*)(kaddr
+ NILFS_DIR_REC_LEN(1));
598 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
- NILFS_DIR_REC_LEN(1));
599 de
->inode
= cpu_to_le64(parent
->i_ino
);
600 memcpy(de
->name
, "..\0", 4);
601 nilfs_set_de_type(de
, inode
);
602 kunmap_atomic(kaddr
);
603 nilfs_commit_chunk(page
, mapping
, 0, chunk_size
);
610 * routine to check that the specified directory is empty (for rmdir)
612 int nilfs_empty_dir(struct inode
*inode
)
614 struct page
*page
= NULL
;
615 unsigned long i
, npages
= dir_pages(inode
);
617 for (i
= 0; i
< npages
; i
++) {
619 struct nilfs_dir_entry
*de
;
621 page
= nilfs_get_page(inode
, i
);
625 kaddr
= page_address(page
);
626 de
= (struct nilfs_dir_entry
*)kaddr
;
627 kaddr
+= nilfs_last_byte(inode
, i
) - NILFS_DIR_REC_LEN(1);
629 while ((char *)de
<= kaddr
) {
630 if (de
->rec_len
== 0) {
631 nilfs_error(inode
->i_sb
, __func__
,
632 "zero-length directory entry (kaddr=%p, de=%p)",
636 if (de
->inode
!= 0) {
637 /* check for . and .. */
638 if (de
->name
[0] != '.')
640 if (de
->name_len
> 2)
642 if (de
->name_len
< 2) {
644 cpu_to_le64(inode
->i_ino
))
646 } else if (de
->name
[1] != '.')
649 de
= nilfs_next_entry(de
);
651 nilfs_put_page(page
);
656 nilfs_put_page(page
);
660 const struct file_operations nilfs_dir_operations
= {
661 .llseek
= generic_file_llseek
,
662 .read
= generic_read_dir
,
663 .iterate_shared
= nilfs_readdir
,
664 .unlocked_ioctl
= nilfs_ioctl
,
666 .compat_ioctl
= nilfs_compat_ioctl
,
667 #endif /* CONFIG_COMPAT */
668 .fsync
= nilfs_sync_file
,