4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/dir.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * ext2 directory handling functions
17 * Big-endian to little-endian byte-swapping/bitmaps by
18 * David S. Miller (davem@caip.rutgers.edu), 1995
20 * All code that works with directory layout had been switched to pagecache
25 #include <linux/pagemap.h>
26 #include <linux/smp_lock.h>
28 typedef struct ext2_dir_entry_2 ext2_dirent
;
31 * ext2 uses block-sized chunks. Arguably, sector-sized ones would be
32 * more robust, but we have what we have
34 static inline unsigned ext2_chunk_size(struct inode
*inode
)
36 return inode
->i_sb
->s_blocksize
;
39 static inline void ext2_put_page(struct page
*page
)
42 page_cache_release(page
);
45 static inline unsigned long dir_pages(struct inode
*inode
)
47 return (inode
->i_size
+PAGE_CACHE_SIZE
-1)>>PAGE_CACHE_SHIFT
;
51 * Return the offset into page `page_nr' of the last valid
52 * byte in that page, plus one.
55 ext2_last_byte(struct inode
*inode
, unsigned long page_nr
)
57 unsigned last_byte
= inode
->i_size
;
59 last_byte
-= page_nr
<< PAGE_CACHE_SHIFT
;
60 if (last_byte
> PAGE_CACHE_SIZE
)
61 last_byte
= PAGE_CACHE_SIZE
;
65 static int ext2_commit_chunk(struct page
*page
, unsigned from
, unsigned to
)
67 #if 0 // mask by Victor Yu. 02-12-2007
68 struct inode
*dir
= page
->mapping
->host
;
70 struct inode
*dir
= page
->u
.xx
.mapping
->host
;
74 #if 0 // mask by Victor Yu. 02-12-2007
75 page
->mapping
->a_ops
->commit_write(NULL
, page
, from
, to
);
77 page
->u
.xx
.mapping
->a_ops
->commit_write(NULL
, page
, from
, to
);
80 err
= write_one_page(page
, 1);
86 static void ext2_check_page(struct page
*page
)
88 #if 0 // mask by Victor Yu. 02-12-2007
89 struct inode
*dir
= page
->mapping
->host
;
91 struct inode
*dir
= page
->u
.xx
.mapping
->host
;
93 struct super_block
*sb
= dir
->i_sb
;
94 unsigned chunk_size
= ext2_chunk_size(dir
);
95 char *kaddr
= page_address(page
);
96 u32 max_inumber
= le32_to_cpu(EXT2_SB(sb
)->s_es
->s_inodes_count
);
97 unsigned offs
, rec_len
;
98 unsigned limit
= PAGE_CACHE_SIZE
;
102 if ((dir
->i_size
>> PAGE_CACHE_SHIFT
) == page
->index
) {
103 limit
= dir
->i_size
& ~PAGE_CACHE_MASK
;
104 if (limit
& (chunk_size
- 1))
109 for (offs
= 0; offs
<= limit
- EXT2_DIR_REC_LEN(1); offs
+= rec_len
) {
110 p
= (ext2_dirent
*)(kaddr
+ offs
);
111 rec_len
= le16_to_cpu(p
->rec_len
);
113 if (rec_len
< EXT2_DIR_REC_LEN(1))
117 if (rec_len
< EXT2_DIR_REC_LEN(p
->name_len
))
119 if (((offs
+ rec_len
- 1) ^ offs
) & ~(chunk_size
-1))
121 if (le32_to_cpu(p
->inode
) > max_inumber
)
127 SetPageChecked(page
);
130 /* Too bad, we had an error */
133 ext2_error(sb
, "ext2_check_page",
134 "size of directory #%lu is not a multiple of chunk size",
139 error
= "rec_len is smaller than minimal";
142 error
= "unaligned directory entry";
145 error
= "rec_len is too small for name_len";
148 error
= "directory entry across blocks";
151 error
= "inode out of bounds";
153 ext2_error (sb
, "ext2_check_page", "bad entry in directory #%lu: %s - "
154 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
155 dir
->i_ino
, error
, (page
->index
<<PAGE_CACHE_SHIFT
)+offs
,
156 (unsigned long) le32_to_cpu(p
->inode
),
157 rec_len
, p
->name_len
);
160 p
= (ext2_dirent
*)(kaddr
+ offs
);
161 ext2_error (sb
, "ext2_check_page",
162 "entry in directory #%lu spans the page boundary"
163 "offset=%lu, inode=%lu",
164 dir
->i_ino
, (page
->index
<<PAGE_CACHE_SHIFT
)+offs
,
165 (unsigned long) le32_to_cpu(p
->inode
));
167 SetPageChecked(page
);
171 static struct page
* ext2_get_page(struct inode
*dir
, unsigned long n
)
173 struct address_space
*mapping
= dir
->i_mapping
;
174 struct page
*page
= read_mapping_page(mapping
, n
, NULL
);
176 wait_on_page_locked(page
);
178 if (!PageUptodate(page
))
180 if (!PageChecked(page
))
181 ext2_check_page(page
);
189 return ERR_PTR(-EIO
);
193 * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
195 * len <= EXT2_NAME_LEN and de != NULL are guaranteed by caller.
197 static inline int ext2_match (int len
, const char * const name
,
198 struct ext2_dir_entry_2
* de
)
200 if (len
!= de
->name_len
)
204 return !memcmp(name
, de
->name
, len
);
208 * p is at least 6 bytes before the end of page
210 static inline ext2_dirent
*ext2_next_entry(ext2_dirent
*p
)
212 return (ext2_dirent
*)((char*)p
+ le16_to_cpu(p
->rec_len
));
215 static inline unsigned
216 ext2_validate_entry(char *base
, unsigned offset
, unsigned mask
)
218 ext2_dirent
*de
= (ext2_dirent
*)(base
+ offset
);
219 ext2_dirent
*p
= (ext2_dirent
*)(base
+ (offset
&mask
));
220 while ((char*)p
< (char*)de
) {
223 p
= ext2_next_entry(p
);
225 return (char *)p
- base
;
228 static unsigned char ext2_filetype_table
[EXT2_FT_MAX
] = {
229 [EXT2_FT_UNKNOWN
] = DT_UNKNOWN
,
230 [EXT2_FT_REG_FILE
] = DT_REG
,
231 [EXT2_FT_DIR
] = DT_DIR
,
232 [EXT2_FT_CHRDEV
] = DT_CHR
,
233 [EXT2_FT_BLKDEV
] = DT_BLK
,
234 [EXT2_FT_FIFO
] = DT_FIFO
,
235 [EXT2_FT_SOCK
] = DT_SOCK
,
236 [EXT2_FT_SYMLINK
] = DT_LNK
,
240 static unsigned char ext2_type_by_mode
[S_IFMT
>> S_SHIFT
] = {
241 [S_IFREG
>> S_SHIFT
] = EXT2_FT_REG_FILE
,
242 [S_IFDIR
>> S_SHIFT
] = EXT2_FT_DIR
,
243 [S_IFCHR
>> S_SHIFT
] = EXT2_FT_CHRDEV
,
244 [S_IFBLK
>> S_SHIFT
] = EXT2_FT_BLKDEV
,
245 [S_IFIFO
>> S_SHIFT
] = EXT2_FT_FIFO
,
246 [S_IFSOCK
>> S_SHIFT
] = EXT2_FT_SOCK
,
247 [S_IFLNK
>> S_SHIFT
] = EXT2_FT_SYMLINK
,
250 static inline void ext2_set_de_type(ext2_dirent
*de
, struct inode
*inode
)
252 mode_t mode
= inode
->i_mode
;
253 if (EXT2_HAS_INCOMPAT_FEATURE(inode
->i_sb
, EXT2_FEATURE_INCOMPAT_FILETYPE
))
254 de
->file_type
= ext2_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
260 ext2_readdir (struct file
* filp
, void * dirent
, filldir_t filldir
)
262 loff_t pos
= filp
->f_pos
;
263 struct inode
*inode
= filp
->f_dentry
->d_inode
;
264 struct super_block
*sb
= inode
->i_sb
;
265 unsigned int offset
= pos
& ~PAGE_CACHE_MASK
;
266 unsigned long n
= pos
>> PAGE_CACHE_SHIFT
;
267 unsigned long npages
= dir_pages(inode
);
268 unsigned chunk_mask
= ~(ext2_chunk_size(inode
)-1);
269 unsigned char *types
= NULL
;
270 int need_revalidate
= filp
->f_version
!= inode
->i_version
;
272 if (pos
> inode
->i_size
- EXT2_DIR_REC_LEN(1))
275 if (EXT2_HAS_INCOMPAT_FEATURE(sb
, EXT2_FEATURE_INCOMPAT_FILETYPE
))
276 types
= ext2_filetype_table
;
278 for ( ; n
< npages
; n
++, offset
= 0) {
281 struct page
*page
= ext2_get_page(inode
, n
);
284 ext2_error(sb
, __FUNCTION__
,
287 filp
->f_pos
+= PAGE_CACHE_SIZE
- offset
;
290 kaddr
= page_address(page
);
291 if (unlikely(need_revalidate
)) {
293 offset
= ext2_validate_entry(kaddr
, offset
, chunk_mask
);
294 filp
->f_pos
= (n
<<PAGE_CACHE_SHIFT
) + offset
;
296 filp
->f_version
= inode
->i_version
;
299 de
= (ext2_dirent
*)(kaddr
+offset
);
300 limit
= kaddr
+ ext2_last_byte(inode
, n
) - EXT2_DIR_REC_LEN(1);
301 for ( ;(char*)de
<= limit
; de
= ext2_next_entry(de
)) {
302 if (de
->rec_len
== 0) {
303 ext2_error(sb
, __FUNCTION__
,
304 "zero-length directory entry");
310 unsigned char d_type
= DT_UNKNOWN
;
312 if (types
&& de
->file_type
< EXT2_FT_MAX
)
313 d_type
= types
[de
->file_type
];
315 offset
= (char *)de
- kaddr
;
316 over
= filldir(dirent
, de
->name
, de
->name_len
,
317 (n
<<PAGE_CACHE_SHIFT
) | offset
,
318 le32_to_cpu(de
->inode
), d_type
);
324 filp
->f_pos
+= le16_to_cpu(de
->rec_len
);
334 * finds an entry in the specified directory with the wanted name. It
335 * returns the page in which the entry was found, and the entry itself
336 * (as a parameter - res_dir). Page is returned mapped and unlocked.
337 * Entry is guaranteed to be valid.
339 struct ext2_dir_entry_2
* ext2_find_entry (struct inode
* dir
,
340 struct dentry
*dentry
, struct page
** res_page
)
342 const char *name
= dentry
->d_name
.name
;
343 int namelen
= dentry
->d_name
.len
;
344 unsigned reclen
= EXT2_DIR_REC_LEN(namelen
);
345 unsigned long start
, n
;
346 unsigned long npages
= dir_pages(dir
);
347 struct page
*page
= NULL
;
348 struct ext2_inode_info
*ei
= EXT2_I(dir
);
357 start
= ei
->i_dir_start_lookup
;
363 page
= ext2_get_page(dir
, n
);
365 kaddr
= page_address(page
);
366 de
= (ext2_dirent
*) kaddr
;
367 kaddr
+= ext2_last_byte(dir
, n
) - reclen
;
368 while ((char *) de
<= kaddr
) {
369 if (de
->rec_len
== 0) {
370 ext2_error(dir
->i_sb
, __FUNCTION__
,
371 "zero-length directory entry");
375 if (ext2_match (namelen
, name
, de
))
377 de
= ext2_next_entry(de
);
383 } while (n
!= start
);
389 ei
->i_dir_start_lookup
= n
;
393 struct ext2_dir_entry_2
* ext2_dotdot (struct inode
*dir
, struct page
**p
)
395 struct page
*page
= ext2_get_page(dir
, 0);
396 ext2_dirent
*de
= NULL
;
399 de
= ext2_next_entry((ext2_dirent
*) page_address(page
));
405 ino_t
ext2_inode_by_name(struct inode
* dir
, struct dentry
*dentry
)
408 struct ext2_dir_entry_2
* de
;
411 de
= ext2_find_entry (dir
, dentry
, &page
);
413 res
= le32_to_cpu(de
->inode
);
419 /* Releases the page */
420 void ext2_set_link(struct inode
*dir
, struct ext2_dir_entry_2
*de
,
421 struct page
*page
, struct inode
*inode
)
423 unsigned from
= (char *) de
- (char *) page_address(page
);
424 unsigned to
= from
+ le16_to_cpu(de
->rec_len
);
428 #if 0 // mask by Victor Yu. 02-12-2007
429 err
= page
->mapping
->a_ops
->prepare_write(NULL
, page
, from
, to
);
431 err
= page
->u
.xx
.mapping
->a_ops
->prepare_write(NULL
, page
, from
, to
);
434 de
->inode
= cpu_to_le32(inode
->i_ino
);
435 ext2_set_de_type (de
, inode
);
436 err
= ext2_commit_chunk(page
, from
, to
);
438 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME_SEC
;
439 EXT2_I(dir
)->i_flags
&= ~EXT2_BTREE_FL
;
440 mark_inode_dirty(dir
);
446 int ext2_add_link (struct dentry
*dentry
, struct inode
*inode
)
448 struct inode
*dir
= dentry
->d_parent
->d_inode
;
449 const char *name
= dentry
->d_name
.name
;
450 int namelen
= dentry
->d_name
.len
;
451 unsigned chunk_size
= ext2_chunk_size(dir
);
452 unsigned reclen
= EXT2_DIR_REC_LEN(namelen
);
453 unsigned short rec_len
, name_len
;
454 struct page
*page
= NULL
;
456 unsigned long npages
= dir_pages(dir
);
463 * We take care of directory expansion in the same loop.
464 * This code plays outside i_size, so it locks the page
465 * to protect that region.
467 for (n
= 0; n
<= npages
; n
++) {
470 page
= ext2_get_page(dir
, n
);
475 kaddr
= page_address(page
);
476 dir_end
= kaddr
+ ext2_last_byte(dir
, n
);
477 de
= (ext2_dirent
*)kaddr
;
478 kaddr
+= PAGE_CACHE_SIZE
- reclen
;
479 while ((char *)de
<= kaddr
) {
480 if ((char *)de
== dir_end
) {
483 rec_len
= chunk_size
;
484 de
->rec_len
= cpu_to_le16(chunk_size
);
488 if (de
->rec_len
== 0) {
489 ext2_error(dir
->i_sb
, __FUNCTION__
,
490 "zero-length directory entry");
495 if (ext2_match (namelen
, name
, de
))
497 name_len
= EXT2_DIR_REC_LEN(de
->name_len
);
498 rec_len
= le16_to_cpu(de
->rec_len
);
499 if (!de
->inode
&& rec_len
>= reclen
)
501 if (rec_len
>= name_len
+ reclen
)
503 de
= (ext2_dirent
*) ((char *) de
+ rec_len
);
512 from
= (char*)de
- (char*)page_address(page
);
514 #if 0 // mask by Victor yu. 02-12-2007
515 err
= page
->mapping
->a_ops
->prepare_write(NULL
, page
, from
, to
);
517 err
= page
->u
.xx
.mapping
->a_ops
->prepare_write(NULL
, page
, from
, to
);
522 ext2_dirent
*de1
= (ext2_dirent
*) ((char *) de
+ name_len
);
523 de1
->rec_len
= cpu_to_le16(rec_len
- name_len
);
524 de
->rec_len
= cpu_to_le16(name_len
);
527 de
->name_len
= namelen
;
528 memcpy (de
->name
, name
, namelen
);
529 de
->inode
= cpu_to_le32(inode
->i_ino
);
530 ext2_set_de_type (de
, inode
);
531 err
= ext2_commit_chunk(page
, from
, to
);
532 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME_SEC
;
533 EXT2_I(dir
)->i_flags
&= ~EXT2_BTREE_FL
;
534 mark_inode_dirty(dir
);
546 * ext2_delete_entry deletes a directory entry by merging it with the
547 * previous entry. Page is up-to-date. Releases the page.
549 int ext2_delete_entry (struct ext2_dir_entry_2
* dir
, struct page
* page
)
551 #if 0 // mask by Victor Yu. 02-12-2007
552 struct address_space
*mapping
= page
->mapping
;
554 struct address_space
*mapping
= page
->u
.xx
.mapping
;
556 struct inode
*inode
= mapping
->host
;
557 char *kaddr
= page_address(page
);
558 unsigned from
= ((char*)dir
- kaddr
) & ~(ext2_chunk_size(inode
)-1);
559 unsigned to
= ((char*)dir
- kaddr
) + le16_to_cpu(dir
->rec_len
);
560 ext2_dirent
* pde
= NULL
;
561 ext2_dirent
* de
= (ext2_dirent
*) (kaddr
+ from
);
564 while ((char*)de
< (char*)dir
) {
565 if (de
->rec_len
== 0) {
566 ext2_error(inode
->i_sb
, __FUNCTION__
,
567 "zero-length directory entry");
572 de
= ext2_next_entry(de
);
575 from
= (char*)pde
- (char*)page_address(page
);
577 err
= mapping
->a_ops
->prepare_write(NULL
, page
, from
, to
);
580 pde
->rec_len
= cpu_to_le16(to
-from
);
582 err
= ext2_commit_chunk(page
, from
, to
);
583 inode
->i_ctime
= inode
->i_mtime
= CURRENT_TIME_SEC
;
584 EXT2_I(inode
)->i_flags
&= ~EXT2_BTREE_FL
;
585 mark_inode_dirty(inode
);
592 * Set the first fragment of directory.
594 int ext2_make_empty(struct inode
*inode
, struct inode
*parent
)
596 struct address_space
*mapping
= inode
->i_mapping
;
597 struct page
*page
= grab_cache_page(mapping
, 0);
598 unsigned chunk_size
= ext2_chunk_size(inode
);
599 struct ext2_dir_entry_2
* de
;
605 err
= mapping
->a_ops
->prepare_write(NULL
, page
, 0, chunk_size
);
610 kaddr
= kmap_atomic(page
, KM_USER0
);
611 memset(kaddr
, 0, chunk_size
);
612 de
= (struct ext2_dir_entry_2
*)kaddr
;
614 de
->rec_len
= cpu_to_le16(EXT2_DIR_REC_LEN(1));
615 memcpy (de
->name
, ".\0\0", 4);
616 de
->inode
= cpu_to_le32(inode
->i_ino
);
617 ext2_set_de_type (de
, inode
);
619 de
= (struct ext2_dir_entry_2
*)(kaddr
+ EXT2_DIR_REC_LEN(1));
621 de
->rec_len
= cpu_to_le16(chunk_size
- EXT2_DIR_REC_LEN(1));
622 de
->inode
= cpu_to_le32(parent
->i_ino
);
623 memcpy (de
->name
, "..\0", 4);
624 ext2_set_de_type (de
, inode
);
625 kunmap_atomic(kaddr
, KM_USER0
);
626 err
= ext2_commit_chunk(page
, 0, chunk_size
);
628 page_cache_release(page
);
633 * routine to check that the specified directory is empty (for rmdir)
635 int ext2_empty_dir (struct inode
* inode
)
637 struct page
*page
= NULL
;
638 unsigned long i
, npages
= dir_pages(inode
);
640 for (i
= 0; i
< npages
; i
++) {
643 page
= ext2_get_page(inode
, i
);
648 kaddr
= page_address(page
);
649 de
= (ext2_dirent
*)kaddr
;
650 kaddr
+= ext2_last_byte(inode
, i
) - EXT2_DIR_REC_LEN(1);
652 while ((char *)de
<= kaddr
) {
653 if (de
->rec_len
== 0) {
654 ext2_error(inode
->i_sb
, __FUNCTION__
,
655 "zero-length directory entry");
656 printk("kaddr=%p, de=%p\n", kaddr
, de
);
659 if (de
->inode
!= 0) {
660 /* check for . and .. */
661 if (de
->name
[0] != '.')
663 if (de
->name_len
> 2)
665 if (de
->name_len
< 2) {
667 cpu_to_le32(inode
->i_ino
))
669 } else if (de
->name
[1] != '.')
672 de
= ext2_next_entry(de
);
683 const struct file_operations ext2_dir_operations
= {
684 .llseek
= generic_file_llseek
,
685 .read
= generic_read_dir
,
686 .readdir
= ext2_readdir
,
689 .compat_ioctl
= ext2_compat_ioctl
,
691 .fsync
= ext2_sync_file
,