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 */
144 "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";
160 "bad entry in directory #%lu: %s - 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
);
168 "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
169 dir
->i_ino
, (page
->index
<< PAGE_SHIFT
) + offs
,
170 (unsigned long)le64_to_cpu(p
->inode
));
176 static struct page
*nilfs_get_page(struct inode
*dir
, unsigned long n
)
178 struct address_space
*mapping
= dir
->i_mapping
;
179 struct page
*page
= read_mapping_page(mapping
, n
, NULL
);
183 if (unlikely(!PageChecked(page
))) {
184 if (PageError(page
) || !nilfs_check_page(page
))
191 nilfs_put_page(page
);
192 return ERR_PTR(-EIO
);
196 * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
198 * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
201 nilfs_match(int len
, const unsigned char *name
, struct nilfs_dir_entry
*de
)
203 if (len
!= de
->name_len
)
207 return !memcmp(name
, de
->name
, len
);
211 * p is at least 6 bytes before the end of page
213 static struct nilfs_dir_entry
*nilfs_next_entry(struct nilfs_dir_entry
*p
)
215 return (struct nilfs_dir_entry
*)((char *)p
+
216 nilfs_rec_len_from_disk(p
->rec_len
));
220 nilfs_filetype_table
[NILFS_FT_MAX
] = {
221 [NILFS_FT_UNKNOWN
] = DT_UNKNOWN
,
222 [NILFS_FT_REG_FILE
] = DT_REG
,
223 [NILFS_FT_DIR
] = DT_DIR
,
224 [NILFS_FT_CHRDEV
] = DT_CHR
,
225 [NILFS_FT_BLKDEV
] = DT_BLK
,
226 [NILFS_FT_FIFO
] = DT_FIFO
,
227 [NILFS_FT_SOCK
] = DT_SOCK
,
228 [NILFS_FT_SYMLINK
] = DT_LNK
,
233 nilfs_type_by_mode
[S_IFMT
>> S_SHIFT
] = {
234 [S_IFREG
>> S_SHIFT
] = NILFS_FT_REG_FILE
,
235 [S_IFDIR
>> S_SHIFT
] = NILFS_FT_DIR
,
236 [S_IFCHR
>> S_SHIFT
] = NILFS_FT_CHRDEV
,
237 [S_IFBLK
>> S_SHIFT
] = NILFS_FT_BLKDEV
,
238 [S_IFIFO
>> S_SHIFT
] = NILFS_FT_FIFO
,
239 [S_IFSOCK
>> S_SHIFT
] = NILFS_FT_SOCK
,
240 [S_IFLNK
>> S_SHIFT
] = NILFS_FT_SYMLINK
,
243 static void nilfs_set_de_type(struct nilfs_dir_entry
*de
, struct inode
*inode
)
245 umode_t mode
= inode
->i_mode
;
247 de
->file_type
= nilfs_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
250 static int nilfs_readdir(struct file
*file
, struct dir_context
*ctx
)
252 loff_t pos
= ctx
->pos
;
253 struct inode
*inode
= file_inode(file
);
254 struct super_block
*sb
= inode
->i_sb
;
255 unsigned int offset
= pos
& ~PAGE_MASK
;
256 unsigned long n
= pos
>> PAGE_SHIFT
;
257 unsigned long npages
= dir_pages(inode
);
259 if (pos
> inode
->i_size
- NILFS_DIR_REC_LEN(1))
262 for ( ; n
< npages
; n
++, offset
= 0) {
264 struct nilfs_dir_entry
*de
;
265 struct page
*page
= nilfs_get_page(inode
, n
);
268 nilfs_error(sb
, "bad page in #%lu", inode
->i_ino
);
269 ctx
->pos
+= PAGE_SIZE
- offset
;
272 kaddr
= page_address(page
);
273 de
= (struct nilfs_dir_entry
*)(kaddr
+ offset
);
274 limit
= kaddr
+ nilfs_last_byte(inode
, n
) -
275 NILFS_DIR_REC_LEN(1);
276 for ( ; (char *)de
<= limit
; de
= nilfs_next_entry(de
)) {
277 if (de
->rec_len
== 0) {
278 nilfs_error(sb
, "zero-length directory entry");
279 nilfs_put_page(page
);
285 if (de
->file_type
< NILFS_FT_MAX
)
286 t
= nilfs_filetype_table
[de
->file_type
];
290 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
291 le64_to_cpu(de
->inode
), t
)) {
292 nilfs_put_page(page
);
296 ctx
->pos
+= nilfs_rec_len_from_disk(de
->rec_len
);
298 nilfs_put_page(page
);
306 * finds an entry in the specified directory with the wanted name. It
307 * returns the page in which the entry was found, and the entry itself
308 * (as a parameter - res_dir). Page is returned mapped and unlocked.
309 * Entry is guaranteed to be valid.
311 struct nilfs_dir_entry
*
312 nilfs_find_entry(struct inode
*dir
, const struct qstr
*qstr
,
313 struct page
**res_page
)
315 const unsigned char *name
= qstr
->name
;
316 int namelen
= qstr
->len
;
317 unsigned int reclen
= NILFS_DIR_REC_LEN(namelen
);
318 unsigned long start
, n
;
319 unsigned long npages
= dir_pages(dir
);
320 struct page
*page
= NULL
;
321 struct nilfs_inode_info
*ei
= NILFS_I(dir
);
322 struct nilfs_dir_entry
*de
;
330 start
= ei
->i_dir_start_lookup
;
337 page
= nilfs_get_page(dir
, n
);
339 kaddr
= page_address(page
);
340 de
= (struct nilfs_dir_entry
*)kaddr
;
341 kaddr
+= nilfs_last_byte(dir
, n
) - reclen
;
342 while ((char *) de
<= kaddr
) {
343 if (de
->rec_len
== 0) {
344 nilfs_error(dir
->i_sb
,
345 "zero-length directory entry");
346 nilfs_put_page(page
);
349 if (nilfs_match(namelen
, name
, de
))
351 de
= nilfs_next_entry(de
);
353 nilfs_put_page(page
);
357 /* next page is past the blocks we've got */
358 if (unlikely(n
> (dir
->i_blocks
>> (PAGE_SHIFT
- 9)))) {
359 nilfs_error(dir
->i_sb
,
360 "dir %lu size %lld exceeds block count %llu",
361 dir
->i_ino
, dir
->i_size
,
362 (unsigned long long)dir
->i_blocks
);
365 } while (n
!= start
);
371 ei
->i_dir_start_lookup
= n
;
375 struct nilfs_dir_entry
*nilfs_dotdot(struct inode
*dir
, struct page
**p
)
377 struct page
*page
= nilfs_get_page(dir
, 0);
378 struct nilfs_dir_entry
*de
= NULL
;
381 de
= nilfs_next_entry(
382 (struct nilfs_dir_entry
*)page_address(page
));
388 ino_t
nilfs_inode_by_name(struct inode
*dir
, const struct qstr
*qstr
)
391 struct nilfs_dir_entry
*de
;
394 de
= nilfs_find_entry(dir
, qstr
, &page
);
396 res
= le64_to_cpu(de
->inode
);
403 /* Releases the page */
404 void nilfs_set_link(struct inode
*dir
, struct nilfs_dir_entry
*de
,
405 struct page
*page
, struct inode
*inode
)
407 unsigned int from
= (char *)de
- (char *)page_address(page
);
408 unsigned int to
= from
+ nilfs_rec_len_from_disk(de
->rec_len
);
409 struct address_space
*mapping
= page
->mapping
;
413 err
= nilfs_prepare_chunk(page
, from
, to
);
415 de
->inode
= cpu_to_le64(inode
->i_ino
);
416 nilfs_set_de_type(de
, inode
);
417 nilfs_commit_chunk(page
, mapping
, from
, to
);
418 nilfs_put_page(page
);
419 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
425 int nilfs_add_link(struct dentry
*dentry
, struct inode
*inode
)
427 struct inode
*dir
= d_inode(dentry
->d_parent
);
428 const unsigned char *name
= dentry
->d_name
.name
;
429 int namelen
= dentry
->d_name
.len
;
430 unsigned int chunk_size
= nilfs_chunk_size(dir
);
431 unsigned int reclen
= NILFS_DIR_REC_LEN(namelen
);
432 unsigned short rec_len
, name_len
;
433 struct page
*page
= NULL
;
434 struct nilfs_dir_entry
*de
;
435 unsigned long npages
= dir_pages(dir
);
438 unsigned int from
, to
;
442 * We take care of directory expansion in the same loop.
443 * This code plays outside i_size, so it locks the page
444 * to protect that region.
446 for (n
= 0; n
<= npages
; n
++) {
449 page
= nilfs_get_page(dir
, n
);
454 kaddr
= page_address(page
);
455 dir_end
= kaddr
+ nilfs_last_byte(dir
, n
);
456 de
= (struct nilfs_dir_entry
*)kaddr
;
457 kaddr
+= PAGE_SIZE
- reclen
;
458 while ((char *)de
<= kaddr
) {
459 if ((char *)de
== dir_end
) {
462 rec_len
= chunk_size
;
463 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
);
467 if (de
->rec_len
== 0) {
468 nilfs_error(dir
->i_sb
,
469 "zero-length directory entry");
474 if (nilfs_match(namelen
, name
, de
))
476 name_len
= NILFS_DIR_REC_LEN(de
->name_len
);
477 rec_len
= nilfs_rec_len_from_disk(de
->rec_len
);
478 if (!de
->inode
&& rec_len
>= reclen
)
480 if (rec_len
>= name_len
+ reclen
)
482 de
= (struct nilfs_dir_entry
*)((char *)de
+ rec_len
);
485 nilfs_put_page(page
);
491 from
= (char *)de
- (char *)page_address(page
);
493 err
= nilfs_prepare_chunk(page
, from
, to
);
497 struct nilfs_dir_entry
*de1
;
499 de1
= (struct nilfs_dir_entry
*)((char *)de
+ name_len
);
500 de1
->rec_len
= nilfs_rec_len_to_disk(rec_len
- name_len
);
501 de
->rec_len
= nilfs_rec_len_to_disk(name_len
);
504 de
->name_len
= namelen
;
505 memcpy(de
->name
, name
, namelen
);
506 de
->inode
= cpu_to_le64(inode
->i_ino
);
507 nilfs_set_de_type(de
, inode
);
508 nilfs_commit_chunk(page
, page
->mapping
, from
, to
);
509 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
510 nilfs_mark_inode_dirty(dir
);
513 nilfs_put_page(page
);
522 * nilfs_delete_entry deletes a directory entry by merging it with the
523 * previous entry. Page is up-to-date. Releases the page.
525 int nilfs_delete_entry(struct nilfs_dir_entry
*dir
, struct page
*page
)
527 struct address_space
*mapping
= page
->mapping
;
528 struct inode
*inode
= mapping
->host
;
529 char *kaddr
= page_address(page
);
530 unsigned int from
, to
;
531 struct nilfs_dir_entry
*de
, *pde
= NULL
;
534 from
= ((char *)dir
- kaddr
) & ~(nilfs_chunk_size(inode
) - 1);
535 to
= ((char *)dir
- kaddr
) + nilfs_rec_len_from_disk(dir
->rec_len
);
536 de
= (struct nilfs_dir_entry
*)(kaddr
+ from
);
538 while ((char *)de
< (char *)dir
) {
539 if (de
->rec_len
== 0) {
540 nilfs_error(inode
->i_sb
,
541 "zero-length directory entry");
546 de
= nilfs_next_entry(de
);
549 from
= (char *)pde
- (char *)page_address(page
);
551 err
= nilfs_prepare_chunk(page
, from
, to
);
554 pde
->rec_len
= nilfs_rec_len_to_disk(to
- from
);
556 nilfs_commit_chunk(page
, mapping
, from
, to
);
557 inode
->i_ctime
= inode
->i_mtime
= CURRENT_TIME
;
559 nilfs_put_page(page
);
564 * Set the first fragment of directory.
566 int nilfs_make_empty(struct inode
*inode
, struct inode
*parent
)
568 struct address_space
*mapping
= inode
->i_mapping
;
569 struct page
*page
= grab_cache_page(mapping
, 0);
570 unsigned int chunk_size
= nilfs_chunk_size(inode
);
571 struct nilfs_dir_entry
*de
;
578 err
= nilfs_prepare_chunk(page
, 0, chunk_size
);
583 kaddr
= kmap_atomic(page
);
584 memset(kaddr
, 0, chunk_size
);
585 de
= (struct nilfs_dir_entry
*)kaddr
;
587 de
->rec_len
= nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
588 memcpy(de
->name
, ".\0\0", 4);
589 de
->inode
= cpu_to_le64(inode
->i_ino
);
590 nilfs_set_de_type(de
, inode
);
592 de
= (struct nilfs_dir_entry
*)(kaddr
+ NILFS_DIR_REC_LEN(1));
594 de
->rec_len
= nilfs_rec_len_to_disk(chunk_size
- NILFS_DIR_REC_LEN(1));
595 de
->inode
= cpu_to_le64(parent
->i_ino
);
596 memcpy(de
->name
, "..\0", 4);
597 nilfs_set_de_type(de
, inode
);
598 kunmap_atomic(kaddr
);
599 nilfs_commit_chunk(page
, mapping
, 0, chunk_size
);
606 * routine to check that the specified directory is empty (for rmdir)
608 int nilfs_empty_dir(struct inode
*inode
)
610 struct page
*page
= NULL
;
611 unsigned long i
, npages
= dir_pages(inode
);
613 for (i
= 0; i
< npages
; i
++) {
615 struct nilfs_dir_entry
*de
;
617 page
= nilfs_get_page(inode
, i
);
621 kaddr
= page_address(page
);
622 de
= (struct nilfs_dir_entry
*)kaddr
;
623 kaddr
+= nilfs_last_byte(inode
, i
) - NILFS_DIR_REC_LEN(1);
625 while ((char *)de
<= kaddr
) {
626 if (de
->rec_len
== 0) {
627 nilfs_error(inode
->i_sb
,
628 "zero-length directory entry (kaddr=%p, de=%p)",
632 if (de
->inode
!= 0) {
633 /* check for . and .. */
634 if (de
->name
[0] != '.')
636 if (de
->name_len
> 2)
638 if (de
->name_len
< 2) {
640 cpu_to_le64(inode
->i_ino
))
642 } else if (de
->name
[1] != '.')
645 de
= nilfs_next_entry(de
);
647 nilfs_put_page(page
);
652 nilfs_put_page(page
);
656 const struct file_operations nilfs_dir_operations
= {
657 .llseek
= generic_file_llseek
,
658 .read
= generic_read_dir
,
659 .iterate_shared
= nilfs_readdir
,
660 .unlocked_ioctl
= nilfs_ioctl
,
662 .compat_ioctl
= nilfs_compat_ioctl
,
663 #endif /* CONFIG_COMPAT */
664 .fsync
= nilfs_sync_file
,