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 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 nilfs_last_byte(struct inode
*inode
, unsigned long page_nr
)
66 unsigned 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 from
, unsigned to
)
76 loff_t pos
= page_offset(page
) + from
;
78 return __block_write_begin(page
, pos
, to
- from
, nilfs_get_block
);
81 static void nilfs_commit_chunk(struct page
*page
,
82 struct address_space
*mapping
,
83 unsigned from
, unsigned to
)
85 struct inode
*dir
= mapping
->host
;
86 loff_t pos
= page_offset(page
) + from
;
87 unsigned len
= to
- from
;
88 unsigned nr_dirty
, copied
;
91 nr_dirty
= nilfs_page_count_clean_buffers(page
, from
, to
);
92 copied
= block_write_end(NULL
, mapping
, pos
, len
, len
, page
, NULL
);
93 if (pos
+ copied
> dir
->i_size
)
94 i_size_write(dir
, pos
+ copied
);
96 nilfs_set_transaction_flag(NILFS_TI_SYNC
);
97 err
= nilfs_set_file_dirty(dir
, nr_dirty
);
98 WARN_ON(err
); /* do not happen */
102 static bool nilfs_check_page(struct page
*page
)
104 struct inode
*dir
= page
->mapping
->host
;
105 struct super_block
*sb
= dir
->i_sb
;
106 unsigned chunk_size
= nilfs_chunk_size(dir
);
107 char *kaddr
= page_address(page
);
108 unsigned offs
, rec_len
;
109 unsigned limit
= PAGE_SIZE
;
110 struct nilfs_dir_entry
*p
;
113 if ((dir
->i_size
>> PAGE_SHIFT
) == page
->index
) {
114 limit
= dir
->i_size
& ~PAGE_MASK
;
115 if (limit
& (chunk_size
- 1))
120 for (offs
= 0; offs
<= limit
- NILFS_DIR_REC_LEN(1); offs
+= rec_len
) {
121 p
= (struct nilfs_dir_entry
*)(kaddr
+ offs
);
122 rec_len
= nilfs_rec_len_from_disk(p
->rec_len
);
124 if (rec_len
< NILFS_DIR_REC_LEN(1))
128 if (rec_len
< NILFS_DIR_REC_LEN(p
->name_len
))
130 if (((offs
+ rec_len
- 1) ^ offs
) & ~(chunk_size
-1))
136 SetPageChecked(page
);
139 /* Too bad, we had an error */
142 nilfs_error(sb
, "nilfs_check_page",
143 "size of directory #%lu is not a multiple of chunk size",
148 error
= "rec_len is smaller than minimal";
151 error
= "unaligned directory entry";
154 error
= "rec_len is too small for name_len";
157 error
= "directory entry across blocks";
159 nilfs_error(sb
, "nilfs_check_page", "bad entry in directory #%lu: %s - "
160 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
161 dir
->i_ino
, error
, (page
->index
<<PAGE_SHIFT
)+offs
,
162 (unsigned long) le64_to_cpu(p
->inode
),
163 rec_len
, p
->name_len
);
166 p
= (struct nilfs_dir_entry
*)(kaddr
+ offs
);
167 nilfs_error(sb
, "nilfs_check_page",
168 "entry in directory #%lu spans the page boundary"
169 "offset=%lu, inode=%lu",
170 dir
->i_ino
, (page
->index
<<PAGE_SHIFT
)+offs
,
171 (unsigned long) le64_to_cpu(p
->inode
));
177 static struct page
*nilfs_get_page(struct inode
*dir
, unsigned long n
)
179 struct address_space
*mapping
= dir
->i_mapping
;
180 struct page
*page
= read_mapping_page(mapping
, n
, NULL
);
184 if (unlikely(!PageChecked(page
))) {
185 if (PageError(page
) || !nilfs_check_page(page
))
192 nilfs_put_page(page
);
193 return ERR_PTR(-EIO
);
197 * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
199 * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
202 nilfs_match(int len
, const unsigned char *name
, struct nilfs_dir_entry
*de
)
204 if (len
!= de
->name_len
)
208 return !memcmp(name
, de
->name
, len
);
212 * p is at least 6 bytes before the end of page
214 static struct nilfs_dir_entry
*nilfs_next_entry(struct nilfs_dir_entry
*p
)
216 return (struct nilfs_dir_entry
*)((char *)p
+
217 nilfs_rec_len_from_disk(p
->rec_len
));
221 nilfs_filetype_table
[NILFS_FT_MAX
] = {
222 [NILFS_FT_UNKNOWN
] = DT_UNKNOWN
,
223 [NILFS_FT_REG_FILE
] = DT_REG
,
224 [NILFS_FT_DIR
] = DT_DIR
,
225 [NILFS_FT_CHRDEV
] = DT_CHR
,
226 [NILFS_FT_BLKDEV
] = DT_BLK
,
227 [NILFS_FT_FIFO
] = DT_FIFO
,
228 [NILFS_FT_SOCK
] = DT_SOCK
,
229 [NILFS_FT_SYMLINK
] = DT_LNK
,
234 nilfs_type_by_mode
[S_IFMT
>> S_SHIFT
] = {
235 [S_IFREG
>> S_SHIFT
] = NILFS_FT_REG_FILE
,
236 [S_IFDIR
>> S_SHIFT
] = NILFS_FT_DIR
,
237 [S_IFCHR
>> S_SHIFT
] = NILFS_FT_CHRDEV
,
238 [S_IFBLK
>> S_SHIFT
] = NILFS_FT_BLKDEV
,
239 [S_IFIFO
>> S_SHIFT
] = NILFS_FT_FIFO
,
240 [S_IFSOCK
>> S_SHIFT
] = NILFS_FT_SOCK
,
241 [S_IFLNK
>> S_SHIFT
] = NILFS_FT_SYMLINK
,
244 static void nilfs_set_de_type(struct nilfs_dir_entry
*de
, struct inode
*inode
)
246 umode_t mode
= inode
->i_mode
;
248 de
->file_type
= nilfs_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
251 static int nilfs_readdir(struct file
*file
, struct dir_context
*ctx
)
253 loff_t pos
= ctx
->pos
;
254 struct inode
*inode
= file_inode(file
);
255 struct super_block
*sb
= inode
->i_sb
;
256 unsigned int offset
= pos
& ~PAGE_MASK
;
257 unsigned long n
= pos
>> PAGE_SHIFT
;
258 unsigned long npages
= dir_pages(inode
);
259 /* unsigned chunk_mask = ~(nilfs_chunk_size(inode)-1); */
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 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 from
= (char *) de
- (char *) page_address(page
);
412 unsigned 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 chunk_size
= nilfs_chunk_size(dir
);
435 unsigned 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
);
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 from
= ((char *)dir
- kaddr
) & ~(nilfs_chunk_size(inode
) - 1);
535 unsigned to
= ((char *)dir
- kaddr
) +
536 nilfs_rec_len_from_disk(dir
->rec_len
);
537 struct nilfs_dir_entry
*pde
= NULL
;
538 struct nilfs_dir_entry
*de
= (struct nilfs_dir_entry
*)(kaddr
+ from
);
541 while ((char *)de
< (char *)dir
) {
542 if (de
->rec_len
== 0) {
543 nilfs_error(inode
->i_sb
, __func__
,
544 "zero-length directory entry");
549 de
= nilfs_next_entry(de
);
552 from
= (char *)pde
- (char *)page_address(page
);
554 err
= nilfs_prepare_chunk(page
, from
, to
);
557 pde
->rec_len
= nilfs_rec_len_to_disk(to
- from
);
559 nilfs_commit_chunk(page
, mapping
, from
, to
);
560 inode
->i_ctime
= inode
->i_mtime
= CURRENT_TIME
;
562 nilfs_put_page(page
);
567 * Set the first fragment of directory.
569 int nilfs_make_empty(struct inode
*inode
, struct inode
*parent
)
571 struct address_space
*mapping
= inode
->i_mapping
;
572 struct page
*page
= grab_cache_page(mapping
, 0);
573 unsigned chunk_size
= nilfs_chunk_size(inode
);
574 struct nilfs_dir_entry
*de
;
581 err
= nilfs_prepare_chunk(page
, 0, chunk_size
);
586 kaddr
= kmap_atomic(page
);
587 memset(kaddr
, 0, chunk_size
);
588 de
= (struct nilfs_dir_entry
*)kaddr
;
590 de
->rec_len
= nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
591 memcpy(de
->name
, ".\0\0", 4);
592 de
->inode
= cpu_to_le64(inode
->i_ino
);
593 nilfs_set_de_type(de
, inode
);
595 de
= (struct nilfs_dir_entry
*)(kaddr
+ NILFS_DIR_REC_LEN(1));
597 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
- NILFS_DIR_REC_LEN(1));
598 de
->inode
= cpu_to_le64(parent
->i_ino
);
599 memcpy(de
->name
, "..\0", 4);
600 nilfs_set_de_type(de
, inode
);
601 kunmap_atomic(kaddr
);
602 nilfs_commit_chunk(page
, mapping
, 0, chunk_size
);
609 * routine to check that the specified directory is empty (for rmdir)
611 int nilfs_empty_dir(struct inode
*inode
)
613 struct page
*page
= NULL
;
614 unsigned long i
, npages
= dir_pages(inode
);
616 for (i
= 0; i
< npages
; i
++) {
618 struct nilfs_dir_entry
*de
;
620 page
= nilfs_get_page(inode
, i
);
624 kaddr
= page_address(page
);
625 de
= (struct nilfs_dir_entry
*)kaddr
;
626 kaddr
+= nilfs_last_byte(inode
, i
) - NILFS_DIR_REC_LEN(1);
628 while ((char *)de
<= kaddr
) {
629 if (de
->rec_len
== 0) {
630 nilfs_error(inode
->i_sb
, __func__
,
631 "zero-length directory entry "
632 "(kaddr=%p, de=%p)\n", kaddr
, de
);
635 if (de
->inode
!= 0) {
636 /* check for . and .. */
637 if (de
->name
[0] != '.')
639 if (de
->name_len
> 2)
641 if (de
->name_len
< 2) {
643 cpu_to_le64(inode
->i_ino
))
645 } else if (de
->name
[1] != '.')
648 de
= nilfs_next_entry(de
);
650 nilfs_put_page(page
);
655 nilfs_put_page(page
);
659 const struct file_operations nilfs_dir_operations
= {
660 .llseek
= generic_file_llseek
,
661 .read
= generic_read_dir
,
662 .iterate_shared
= nilfs_readdir
,
663 .unlocked_ioctl
= nilfs_ioctl
,
665 .compat_ioctl
= nilfs_compat_ioctl
,
666 #endif /* CONFIG_COMPAT */
667 .fsync
= nilfs_sync_file
,