4 * directory handling functions for fat-based filesystems
6 * Written 1992,1993 by Werner Almesberger
8 * Hidden files 1995 by Albert Cahalan <albert@ccs.neu.edu> <adc@coe.neu.edu>
10 * VFAT extensions by Gordon Chaffee <chaffee@plateau.cs.berkeley.edu>
11 * Merged with msdos fs by Henrik Storner <storner@osiris.ping.dk>
12 * Rewritten for constant inumbers. Plugged buffer overrun in readdir(). AV
13 * Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
16 #include <linux/slab.h>
17 #include <linux/compat.h>
18 #include <linux/uaccess.h>
22 * Maximum buffer size of short name.
23 * [(MSDOS_NAME + '.') * max one char + nul]
24 * For msdos style, ['.' (hidden) + MSDOS_NAME + '.' + nul]
26 #define FAT_MAX_SHORT_SIZE ((MSDOS_NAME + 1) * NLS_MAX_CHARSET_SIZE + 1)
28 * Maximum buffer size of unicode chars from slots.
29 * [(max longname slots * 13 (size in a slot) + nul) * sizeof(wchar_t)]
31 #define FAT_MAX_UNI_CHARS ((MSDOS_SLOTS - 1) * 13 + 1)
32 #define FAT_MAX_UNI_SIZE (FAT_MAX_UNI_CHARS * sizeof(wchar_t))
34 static inline unsigned char fat_tolower(unsigned char c
)
36 return ((c
>= 'A') && (c
<= 'Z')) ? c
+32 : c
;
39 static inline loff_t
fat_make_i_pos(struct super_block
*sb
,
40 struct buffer_head
*bh
,
41 struct msdos_dir_entry
*de
)
43 return ((loff_t
)bh
->b_blocknr
<< MSDOS_SB(sb
)->dir_per_block_bits
)
44 | (de
- (struct msdos_dir_entry
*)bh
->b_data
);
47 static inline void fat_dir_readahead(struct inode
*dir
, sector_t iblock
,
50 struct super_block
*sb
= dir
->i_sb
;
51 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
52 struct buffer_head
*bh
;
55 /* This is not a first sector of cluster, or sec_per_clus == 1 */
56 if ((iblock
& (sbi
->sec_per_clus
- 1)) || sbi
->sec_per_clus
== 1)
58 /* root dir of FAT12/FAT16 */
59 if ((sbi
->fat_bits
!= 32) && (dir
->i_ino
== MSDOS_ROOT_INO
))
62 bh
= sb_find_get_block(sb
, phys
);
63 if (bh
== NULL
|| !buffer_uptodate(bh
)) {
64 for (sec
= 0; sec
< sbi
->sec_per_clus
; sec
++)
65 sb_breadahead(sb
, phys
+ sec
);
70 /* Returns the inode number of the directory entry at offset pos. If bh is
71 non-NULL, it is brelse'd before. Pos is incremented. The buffer header is
73 AV. Most often we do it item-by-item. Makes sense to optimize.
74 AV. OK, there we go: if both bh and de are non-NULL we assume that we just
75 AV. want the next entry (took one explicit de=NULL in vfat/namei.c).
76 AV. It's done in fat_get_entry() (inlined), here the slow case lives.
77 AV. Additionally, when we return -1 (i.e. reached the end of directory)
80 static int fat__get_entry(struct inode
*dir
, loff_t
*pos
,
81 struct buffer_head
**bh
, struct msdos_dir_entry
**de
)
83 struct super_block
*sb
= dir
->i_sb
;
84 sector_t phys
, iblock
;
85 unsigned long mapped_blocks
;
93 iblock
= *pos
>> sb
->s_blocksize_bits
;
94 err
= fat_bmap(dir
, iblock
, &phys
, &mapped_blocks
, 0, false);
96 return -1; /* beyond EOF or error */
98 fat_dir_readahead(dir
, iblock
, phys
);
100 *bh
= sb_bread(sb
, phys
);
102 fat_msg_ratelimit(sb
, KERN_ERR
,
103 "Directory bread(block %llu) failed", (llu
)phys
);
104 /* skip this block */
105 *pos
= (iblock
+ 1) << sb
->s_blocksize_bits
;
109 offset
= *pos
& (sb
->s_blocksize
- 1);
110 *pos
+= sizeof(struct msdos_dir_entry
);
111 *de
= (struct msdos_dir_entry
*)((*bh
)->b_data
+ offset
);
116 static inline int fat_get_entry(struct inode
*dir
, loff_t
*pos
,
117 struct buffer_head
**bh
,
118 struct msdos_dir_entry
**de
)
120 /* Fast stuff first */
122 (*de
- (struct msdos_dir_entry
*)(*bh
)->b_data
) <
123 MSDOS_SB(dir
->i_sb
)->dir_per_block
- 1) {
124 *pos
+= sizeof(struct msdos_dir_entry
);
128 return fat__get_entry(dir
, pos
, bh
, de
);
132 * Convert Unicode 16 to UTF-8, translated Unicode, or ASCII.
133 * If uni_xlate is enabled and we can't get a 1:1 conversion, use a
134 * colon as an escape character since it is normally invalid on the vfat
135 * filesystem. The following four characters are the hexadecimal digits
136 * of Unicode value. This lets us do a full dump and restore of Unicode
137 * filenames. We could get into some trouble with long Unicode names,
138 * but ignore that right now.
139 * Ahem... Stack smashing in ring 0 isn't fun. Fixed.
141 static int uni16_to_x8(struct super_block
*sb
, unsigned char *ascii
,
142 const wchar_t *uni
, int len
, struct nls_table
*nls
)
144 int uni_xlate
= MSDOS_SB(sb
)->options
.unicode_xlate
;
153 while (*ip
&& ((len
- NLS_MAX_CHARSET_SIZE
) > 0)) {
155 charlen
= nls
->uni2char(ec
, op
, NLS_MAX_CHARSET_SIZE
);
160 if (uni_xlate
== 1) {
162 op
= hex_byte_pack(op
, ec
>> 8);
163 op
= hex_byte_pack(op
, ec
);
173 fat_msg(sb
, KERN_WARNING
,
174 "filename was truncated while converting.");
181 static inline int fat_uni_to_x8(struct super_block
*sb
, const wchar_t *uni
,
182 unsigned char *buf
, int size
)
184 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
185 if (sbi
->options
.utf8
)
186 return utf16s_to_utf8s(uni
, FAT_MAX_UNI_CHARS
,
187 UTF16_HOST_ENDIAN
, buf
, size
);
189 return uni16_to_x8(sb
, buf
, uni
, size
, sbi
->nls_io
);
193 fat_short2uni(struct nls_table
*t
, unsigned char *c
, int clen
, wchar_t *uni
)
197 charlen
= t
->char2uni(c
, clen
, uni
);
199 *uni
= 0x003f; /* a question mark */
206 fat_short2lower_uni(struct nls_table
*t
, unsigned char *c
,
207 int clen
, wchar_t *uni
)
212 charlen
= t
->char2uni(c
, clen
, &wc
);
214 *uni
= 0x003f; /* a question mark */
216 } else if (charlen
<= 1) {
217 unsigned char nc
= t
->charset2lower
[*c
];
222 charlen
= t
->char2uni(&nc
, 1, uni
);
224 *uni
= 0x003f; /* a question mark */
234 fat_shortname2uni(struct nls_table
*nls
, unsigned char *buf
, int buf_size
,
235 wchar_t *uni_buf
, unsigned short opt
, int lower
)
239 if (opt
& VFAT_SFN_DISPLAY_LOWER
)
240 len
= fat_short2lower_uni(nls
, buf
, buf_size
, uni_buf
);
241 else if (opt
& VFAT_SFN_DISPLAY_WIN95
)
242 len
= fat_short2uni(nls
, buf
, buf_size
, uni_buf
);
243 else if (opt
& VFAT_SFN_DISPLAY_WINNT
) {
245 len
= fat_short2lower_uni(nls
, buf
, buf_size
, uni_buf
);
247 len
= fat_short2uni(nls
, buf
, buf_size
, uni_buf
);
249 len
= fat_short2uni(nls
, buf
, buf_size
, uni_buf
);
254 static inline int fat_name_match(struct msdos_sb_info
*sbi
,
255 const unsigned char *a
, int a_len
,
256 const unsigned char *b
, int b_len
)
261 if (sbi
->options
.name_check
!= 's')
262 return !nls_strnicmp(sbi
->nls_io
, a
, b
, a_len
);
264 return !memcmp(a
, b
, a_len
);
267 enum { PARSE_INVALID
= 1, PARSE_NOT_LONGNAME
, PARSE_EOF
, };
270 * fat_parse_long - Parse extended directory entry.
272 * This function returns zero on success, negative value on error, or one of
275 * %PARSE_INVALID - Directory entry is invalid.
276 * %PARSE_NOT_LONGNAME - Directory entry does not contain longname.
277 * %PARSE_EOF - Directory has no more entries.
279 static int fat_parse_long(struct inode
*dir
, loff_t
*pos
,
280 struct buffer_head
**bh
, struct msdos_dir_entry
**de
,
281 wchar_t **unicode
, unsigned char *nr_slots
)
283 struct msdos_dir_slot
*ds
;
284 unsigned char id
, slot
, slots
, alias_checksum
;
287 *unicode
= __getname();
294 ds
= (struct msdos_dir_slot
*)*de
;
297 return PARSE_INVALID
;
299 if (slots
> 20 || !slots
) /* ceil(256 * 2 / 26) */
300 return PARSE_INVALID
;
302 alias_checksum
= ds
->alias_checksum
;
310 fat16_towchar(*unicode
+ offset
, ds
->name0_4
, 5);
311 fat16_towchar(*unicode
+ offset
+ 5, ds
->name5_10
, 6);
312 fat16_towchar(*unicode
+ offset
+ 11, ds
->name11_12
, 2);
315 (*unicode
)[offset
+ 13] = 0;
316 if (fat_get_entry(dir
, pos
, bh
, de
) < 0)
320 ds
= (struct msdos_dir_slot
*)*de
;
321 if (ds
->attr
!= ATTR_EXT
)
322 return PARSE_NOT_LONGNAME
;
323 if ((ds
->id
& ~0x40) != slot
)
325 if (ds
->alias_checksum
!= alias_checksum
)
328 if ((*de
)->name
[0] == DELETED_FLAG
)
329 return PARSE_INVALID
;
330 if ((*de
)->attr
== ATTR_EXT
)
332 if (IS_FREE((*de
)->name
) || ((*de
)->attr
& ATTR_VOLUME
))
333 return PARSE_INVALID
;
334 if (fat_checksum((*de
)->name
) != alias_checksum
)
341 * fat_parse_short - Parse MS-DOS (short) directory entry.
343 * @de: directory entry to parse
344 * @name: FAT_MAX_SHORT_SIZE array in which to place extracted name
345 * @dot_hidden: Nonzero == prepend '.' to names with ATTR_HIDDEN
347 * Returns the number of characters extracted into 'name'.
349 static int fat_parse_short(struct super_block
*sb
,
350 const struct msdos_dir_entry
*de
,
351 unsigned char *name
, int dot_hidden
)
353 const struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
354 int isvfat
= sbi
->options
.isvfat
;
355 int nocase
= sbi
->options
.nocase
;
356 unsigned short opt_shortname
= sbi
->options
.shortname
;
357 struct nls_table
*nls_disk
= sbi
->nls_disk
;
358 wchar_t uni_name
[14];
359 unsigned char c
, work
[MSDOS_NAME
];
360 unsigned char *ptname
= name
;
361 int chi
, chl
, i
, j
, k
;
363 int name_len
= 0, uni_len
= 0;
365 if (!isvfat
&& dot_hidden
&& (de
->attr
& ATTR_HIDDEN
)) {
370 memcpy(work
, de
->name
, sizeof(work
));
371 /* see namei.c, msdos_format_name */
376 for (i
= 0, j
= 0; i
< 8;) {
380 chl
= fat_shortname2uni(nls_disk
, &work
[i
], 8 - i
,
381 &uni_name
[j
++], opt_shortname
,
382 de
->lcase
& CASE_LOWER_BASE
);
385 ptname
[i
] = nocase
? c
: fat_tolower(c
);
396 for (chi
= 0; chi
< chl
&& i
< 8; chi
++, i
++)
406 fat_short2uni(nls_disk
, ".", 1, &uni_name
[j
++]);
412 for (k
= 8; k
< MSDOS_NAME
;) {
416 chl
= fat_shortname2uni(nls_disk
, &work
[k
], MSDOS_NAME
- k
,
417 &uni_name
[j
++], opt_shortname
,
418 de
->lcase
& CASE_LOWER_EXT
);
422 ptname
[i
] = nocase
? c
: fat_tolower(c
);
431 int offset
= min(chl
, MSDOS_NAME
-k
);
435 for (chi
= 0; chi
< chl
&& k
< MSDOS_NAME
;
446 name_len
+= dotoffset
;
448 if (sbi
->options
.isvfat
) {
449 uni_name
[uni_len
] = 0x0000;
450 name_len
= fat_uni_to_x8(sb
, uni_name
, name
,
459 * Return values: negative -> error/not found, 0 -> found.
461 int fat_search_long(struct inode
*inode
, const unsigned char *name
,
462 int name_len
, struct fat_slot_info
*sinfo
)
464 struct super_block
*sb
= inode
->i_sb
;
465 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
466 struct buffer_head
*bh
= NULL
;
467 struct msdos_dir_entry
*de
;
468 unsigned char nr_slots
;
469 wchar_t *unicode
= NULL
;
470 unsigned char bufname
[FAT_MAX_SHORT_SIZE
];
476 if (fat_get_entry(inode
, &cpos
, &bh
, &de
) == -1)
480 if (de
->name
[0] == DELETED_FLAG
)
482 if (de
->attr
!= ATTR_EXT
&& (de
->attr
& ATTR_VOLUME
))
484 if (de
->attr
!= ATTR_EXT
&& IS_FREE(de
->name
))
486 if (de
->attr
== ATTR_EXT
) {
487 int status
= fat_parse_long(inode
, &cpos
, &bh
, &de
,
488 &unicode
, &nr_slots
);
492 } else if (status
== PARSE_INVALID
)
494 else if (status
== PARSE_NOT_LONGNAME
)
496 else if (status
== PARSE_EOF
)
500 /* Never prepend '.' to hidden files here.
501 * That is done only for msdos mounts (and only when
502 * 'dotsOK=yes'); if we are executing here, it is in the
503 * context of a vfat mount.
505 len
= fat_parse_short(sb
, de
, bufname
, 0);
509 /* Compare shortname */
510 if (fat_name_match(sbi
, name
, name_len
, bufname
, len
))
514 void *longname
= unicode
+ FAT_MAX_UNI_CHARS
;
515 int size
= PATH_MAX
- FAT_MAX_UNI_SIZE
;
517 /* Compare longname */
518 len
= fat_uni_to_x8(sb
, unicode
, longname
, size
);
519 if (fat_name_match(sbi
, name
, name_len
, longname
, len
))
525 nr_slots
++; /* include the de */
526 sinfo
->slot_off
= cpos
- nr_slots
* sizeof(*de
);
527 sinfo
->nr_slots
= nr_slots
;
530 sinfo
->i_pos
= fat_make_i_pos(sb
, sinfo
->bh
, sinfo
->de
);
538 EXPORT_SYMBOL_GPL(fat_search_long
);
540 struct fat_ioctl_filldir_callback
{
541 struct dir_context ctx
;
545 const char *longname
;
547 const char *shortname
;
551 static int __fat_readdir(struct inode
*inode
, struct file
*file
,
552 struct dir_context
*ctx
, int short_only
,
553 struct fat_ioctl_filldir_callback
*both
)
555 struct super_block
*sb
= inode
->i_sb
;
556 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
557 struct buffer_head
*bh
;
558 struct msdos_dir_entry
*de
;
559 unsigned char nr_slots
;
560 wchar_t *unicode
= NULL
;
561 unsigned char bufname
[FAT_MAX_SHORT_SIZE
];
562 int isvfat
= sbi
->options
.isvfat
;
563 const char *fill_name
= NULL
;
566 int short_len
= 0, fill_len
= 0;
569 mutex_lock(&sbi
->s_lock
);
572 /* Fake . and .. for the root directory. */
573 if (inode
->i_ino
== MSDOS_ROOT_INO
) {
574 if (!dir_emit_dots(file
, ctx
))
581 if (cpos
& (sizeof(struct msdos_dir_entry
) - 1)) {
588 if (fat_get_entry(inode
, &cpos
, &bh
, &de
) == -1)
593 * Check for long filename entry, but if short_only, we don't
594 * need to parse long filename.
596 if (isvfat
&& !short_only
) {
597 if (de
->name
[0] == DELETED_FLAG
)
599 if (de
->attr
!= ATTR_EXT
&& (de
->attr
& ATTR_VOLUME
))
601 if (de
->attr
!= ATTR_EXT
&& IS_FREE(de
->name
))
604 if ((de
->attr
& ATTR_VOLUME
) || IS_FREE(de
->name
))
608 if (isvfat
&& de
->attr
== ATTR_EXT
) {
609 int status
= fat_parse_long(inode
, &cpos
, &bh
, &de
,
610 &unicode
, &nr_slots
);
615 } else if (status
== PARSE_INVALID
)
617 else if (status
== PARSE_NOT_LONGNAME
)
619 else if (status
== PARSE_EOF
)
623 void *longname
= unicode
+ FAT_MAX_UNI_CHARS
;
624 int size
= PATH_MAX
- FAT_MAX_UNI_SIZE
;
625 int len
= fat_uni_to_x8(sb
, unicode
, longname
, size
);
627 fill_name
= longname
;
629 /* !both && !short_only, so we don't need shortname. */
633 short_len
= fat_parse_short(sb
, de
, bufname
,
634 sbi
->options
.dotsOK
);
637 /* hack for fat_ioctl_filldir() */
638 both
->longname
= fill_name
;
639 both
->long_len
= fill_len
;
640 both
->shortname
= bufname
;
641 both
->short_len
= short_len
;
648 short_len
= fat_parse_short(sb
, de
, bufname
, sbi
->options
.dotsOK
);
653 fill_len
= short_len
;
656 ctx
->pos
= cpos
- (nr_slots
+ 1) * sizeof(struct msdos_dir_entry
);
657 if (fake_offset
&& ctx
->pos
< 2)
660 if (!memcmp(de
->name
, MSDOS_DOT
, MSDOS_NAME
)) {
661 if (!dir_emit_dot(file
, ctx
))
663 } else if (!memcmp(de
->name
, MSDOS_DOTDOT
, MSDOS_NAME
)) {
664 if (!dir_emit_dotdot(file
, ctx
))
668 loff_t i_pos
= fat_make_i_pos(sb
, bh
, de
);
669 struct inode
*tmp
= fat_iget(sb
, i_pos
);
674 inum
= iunique(sb
, MSDOS_ROOT_INO
);
675 if (!dir_emit(ctx
, fill_name
, fill_len
, inum
,
676 (de
->attr
& ATTR_DIR
) ? DT_DIR
: DT_REG
))
686 if (fake_offset
&& cpos
< 2)
695 mutex_unlock(&sbi
->s_lock
);
700 static int fat_readdir(struct file
*file
, struct dir_context
*ctx
)
702 return __fat_readdir(file_inode(file
), file
, ctx
, 0, NULL
);
705 #define FAT_IOCTL_FILLDIR_FUNC(func, dirent_type) \
706 static int func(struct dir_context *ctx, const char *name, int name_len, \
707 loff_t offset, u64 ino, unsigned int d_type) \
709 struct fat_ioctl_filldir_callback *buf = \
710 container_of(ctx, struct fat_ioctl_filldir_callback, ctx); \
711 struct dirent_type __user *d1 = buf->dirent; \
712 struct dirent_type __user *d2 = d1 + 1; \
718 if (name != NULL) { \
719 /* dirent has only short name */ \
720 if (name_len >= sizeof(d1->d_name)) \
721 name_len = sizeof(d1->d_name) - 1; \
723 if (put_user(0, d2->d_name) || \
724 put_user(0, &d2->d_reclen) || \
725 copy_to_user(d1->d_name, name, name_len) || \
726 put_user(0, d1->d_name + name_len) || \
727 put_user(name_len, &d1->d_reclen)) \
730 /* dirent has short and long name */ \
731 const char *longname = buf->longname; \
732 int long_len = buf->long_len; \
733 const char *shortname = buf->shortname; \
734 int short_len = buf->short_len; \
736 if (long_len >= sizeof(d1->d_name)) \
737 long_len = sizeof(d1->d_name) - 1; \
738 if (short_len >= sizeof(d1->d_name)) \
739 short_len = sizeof(d1->d_name) - 1; \
741 if (copy_to_user(d2->d_name, longname, long_len) || \
742 put_user(0, d2->d_name + long_len) || \
743 put_user(long_len, &d2->d_reclen) || \
744 put_user(ino, &d2->d_ino) || \
745 put_user(offset, &d2->d_off) || \
746 copy_to_user(d1->d_name, shortname, short_len) || \
747 put_user(0, d1->d_name + short_len) || \
748 put_user(short_len, &d1->d_reclen)) \
753 buf->result = -EFAULT; \
757 FAT_IOCTL_FILLDIR_FUNC(fat_ioctl_filldir
, __fat_dirent
)
759 static int fat_ioctl_readdir(struct inode
*inode
, struct file
*file
,
760 void __user
*dirent
, filldir_t filldir
,
761 int short_only
, int both
)
763 struct fat_ioctl_filldir_callback buf
= {
764 .ctx
.actor
= filldir
,
771 inode_lock_shared(inode
);
772 buf
.ctx
.pos
= file
->f_pos
;
774 if (!IS_DEADDIR(inode
)) {
775 ret
= __fat_readdir(inode
, file
, &buf
.ctx
,
776 short_only
, both
? &buf
: NULL
);
777 file
->f_pos
= buf
.ctx
.pos
;
779 inode_unlock_shared(inode
);
785 static long fat_dir_ioctl(struct file
*filp
, unsigned int cmd
,
788 struct inode
*inode
= file_inode(filp
);
789 struct __fat_dirent __user
*d1
= (struct __fat_dirent __user
*)arg
;
790 int short_only
, both
;
793 case VFAT_IOCTL_READDIR_SHORT
:
797 case VFAT_IOCTL_READDIR_BOTH
:
802 return fat_generic_ioctl(filp
, cmd
, arg
);
805 if (!access_ok(VERIFY_WRITE
, d1
, sizeof(struct __fat_dirent
[2])))
808 * Yes, we don't need this put_user() absolutely. However old
809 * code didn't return the right value. So, app use this value,
810 * in order to check whether it is EOF.
812 if (put_user(0, &d1
->d_reclen
))
815 return fat_ioctl_readdir(inode
, filp
, d1
, fat_ioctl_filldir
,
820 #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
821 #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
823 FAT_IOCTL_FILLDIR_FUNC(fat_compat_ioctl_filldir
, compat_dirent
)
825 static long fat_compat_dir_ioctl(struct file
*filp
, unsigned cmd
,
828 struct inode
*inode
= file_inode(filp
);
829 struct compat_dirent __user
*d1
= compat_ptr(arg
);
830 int short_only
, both
;
833 case VFAT_IOCTL_READDIR_SHORT32
:
837 case VFAT_IOCTL_READDIR_BOTH32
:
842 return fat_generic_ioctl(filp
, cmd
, (unsigned long)arg
);
845 if (!access_ok(VERIFY_WRITE
, d1
, sizeof(struct compat_dirent
[2])))
848 * Yes, we don't need this put_user() absolutely. However old
849 * code didn't return the right value. So, app use this value,
850 * in order to check whether it is EOF.
852 if (put_user(0, &d1
->d_reclen
))
855 return fat_ioctl_readdir(inode
, filp
, d1
, fat_compat_ioctl_filldir
,
858 #endif /* CONFIG_COMPAT */
860 const struct file_operations fat_dir_operations
= {
861 .llseek
= generic_file_llseek
,
862 .read
= generic_read_dir
,
863 .iterate_shared
= fat_readdir
,
864 .unlocked_ioctl
= fat_dir_ioctl
,
866 .compat_ioctl
= fat_compat_dir_ioctl
,
868 .fsync
= fat_file_fsync
,
871 static int fat_get_short_entry(struct inode
*dir
, loff_t
*pos
,
872 struct buffer_head
**bh
,
873 struct msdos_dir_entry
**de
)
875 while (fat_get_entry(dir
, pos
, bh
, de
) >= 0) {
876 /* free entry or long name entry or volume label */
877 if (!IS_FREE((*de
)->name
) && !((*de
)->attr
& ATTR_VOLUME
))
884 * The ".." entry can not provide the "struct fat_slot_info" information
885 * for inode, nor a usable i_pos. So, this function provides some information
888 * Since this function walks through the on-disk inodes within a directory,
889 * callers are responsible for taking any locks necessary to prevent the
890 * directory from changing.
892 int fat_get_dotdot_entry(struct inode
*dir
, struct buffer_head
**bh
,
893 struct msdos_dir_entry
**de
)
898 while (fat_get_short_entry(dir
, &offset
, bh
, de
) >= 0) {
899 if (!strncmp((*de
)->name
, MSDOS_DOTDOT
, MSDOS_NAME
))
904 EXPORT_SYMBOL_GPL(fat_get_dotdot_entry
);
906 /* See if directory is empty */
907 int fat_dir_empty(struct inode
*dir
)
909 struct buffer_head
*bh
;
910 struct msdos_dir_entry
*de
;
916 while (fat_get_short_entry(dir
, &cpos
, &bh
, &de
) >= 0) {
917 if (strncmp(de
->name
, MSDOS_DOT
, MSDOS_NAME
) &&
918 strncmp(de
->name
, MSDOS_DOTDOT
, MSDOS_NAME
)) {
926 EXPORT_SYMBOL_GPL(fat_dir_empty
);
929 * fat_subdirs counts the number of sub-directories of dir. It can be run
930 * on directories being created.
932 int fat_subdirs(struct inode
*dir
)
934 struct buffer_head
*bh
;
935 struct msdos_dir_entry
*de
;
941 while (fat_get_short_entry(dir
, &cpos
, &bh
, &de
) >= 0) {
942 if (de
->attr
& ATTR_DIR
)
950 * Scans a directory for a given file (name points to its formatted name).
951 * Returns an error code or zero.
953 int fat_scan(struct inode
*dir
, const unsigned char *name
,
954 struct fat_slot_info
*sinfo
)
956 struct super_block
*sb
= dir
->i_sb
;
960 while (fat_get_short_entry(dir
, &sinfo
->slot_off
, &sinfo
->bh
,
962 if (!strncmp(sinfo
->de
->name
, name
, MSDOS_NAME
)) {
963 sinfo
->slot_off
-= sizeof(*sinfo
->de
);
965 sinfo
->i_pos
= fat_make_i_pos(sb
, sinfo
->bh
, sinfo
->de
);
971 EXPORT_SYMBOL_GPL(fat_scan
);
974 * Scans a directory for a given logstart.
975 * Returns an error code or zero.
977 int fat_scan_logstart(struct inode
*dir
, int i_logstart
,
978 struct fat_slot_info
*sinfo
)
980 struct super_block
*sb
= dir
->i_sb
;
984 while (fat_get_short_entry(dir
, &sinfo
->slot_off
, &sinfo
->bh
,
986 if (fat_get_start(MSDOS_SB(sb
), sinfo
->de
) == i_logstart
) {
987 sinfo
->slot_off
-= sizeof(*sinfo
->de
);
989 sinfo
->i_pos
= fat_make_i_pos(sb
, sinfo
->bh
, sinfo
->de
);
996 static int __fat_remove_entries(struct inode
*dir
, loff_t pos
, int nr_slots
)
998 struct super_block
*sb
= dir
->i_sb
;
999 struct buffer_head
*bh
;
1000 struct msdos_dir_entry
*de
, *endp
;
1001 int err
= 0, orig_slots
;
1005 if (fat_get_entry(dir
, &pos
, &bh
, &de
) < 0) {
1010 orig_slots
= nr_slots
;
1011 endp
= (struct msdos_dir_entry
*)(bh
->b_data
+ sb
->s_blocksize
);
1012 while (nr_slots
&& de
< endp
) {
1013 de
->name
[0] = DELETED_FLAG
;
1017 mark_buffer_dirty_inode(bh
, dir
);
1018 if (IS_DIRSYNC(dir
))
1019 err
= sync_dirty_buffer(bh
);
1024 /* pos is *next* de's position, so this does `- sizeof(de)' */
1025 pos
+= ((orig_slots
- nr_slots
) * sizeof(*de
)) - sizeof(*de
);
1031 int fat_remove_entries(struct inode
*dir
, struct fat_slot_info
*sinfo
)
1033 struct super_block
*sb
= dir
->i_sb
;
1034 struct msdos_dir_entry
*de
;
1035 struct buffer_head
*bh
;
1036 int err
= 0, nr_slots
;
1039 * First stage: Remove the shortname. By this, the directory
1042 nr_slots
= sinfo
->nr_slots
;
1047 while (nr_slots
&& de
>= (struct msdos_dir_entry
*)bh
->b_data
) {
1048 de
->name
[0] = DELETED_FLAG
;
1052 mark_buffer_dirty_inode(bh
, dir
);
1053 if (IS_DIRSYNC(dir
))
1054 err
= sync_dirty_buffer(bh
);
1062 * Second stage: remove the remaining longname slots.
1063 * (This directory entry is already removed, and so return
1066 err
= __fat_remove_entries(dir
, sinfo
->slot_off
, nr_slots
);
1068 fat_msg(sb
, KERN_WARNING
,
1069 "Couldn't remove the long name slots");
1073 dir
->i_mtime
= dir
->i_atime
= current_time(dir
);
1074 if (IS_DIRSYNC(dir
))
1075 (void)fat_sync_inode(dir
);
1077 mark_inode_dirty(dir
);
1081 EXPORT_SYMBOL_GPL(fat_remove_entries
);
1083 static int fat_zeroed_cluster(struct inode
*dir
, sector_t blknr
, int nr_used
,
1084 struct buffer_head
**bhs
, int nr_bhs
)
1086 struct super_block
*sb
= dir
->i_sb
;
1087 sector_t last_blknr
= blknr
+ MSDOS_SB(sb
)->sec_per_clus
;
1090 /* Zeroing the unused blocks on this cluster */
1093 while (blknr
< last_blknr
) {
1094 bhs
[n
] = sb_getblk(sb
, blknr
);
1099 memset(bhs
[n
]->b_data
, 0, sb
->s_blocksize
);
1100 set_buffer_uptodate(bhs
[n
]);
1101 mark_buffer_dirty_inode(bhs
[n
], dir
);
1106 if (IS_DIRSYNC(dir
)) {
1107 err
= fat_sync_bhs(bhs
, n
);
1111 for (i
= 0; i
< n
; i
++)
1116 if (IS_DIRSYNC(dir
)) {
1117 err
= fat_sync_bhs(bhs
, n
);
1121 for (i
= 0; i
< n
; i
++)
1127 for (i
= 0; i
< n
; i
++)
1132 int fat_alloc_new_dir(struct inode
*dir
, struct timespec
*ts
)
1134 struct super_block
*sb
= dir
->i_sb
;
1135 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
1136 struct buffer_head
*bhs
[MAX_BUF_PER_PAGE
];
1137 struct msdos_dir_entry
*de
;
1143 err
= fat_alloc_clusters(dir
, &cluster
, 1);
1147 blknr
= fat_clus_to_blknr(sbi
, cluster
);
1148 bhs
[0] = sb_getblk(sb
, blknr
);
1154 fat_time_unix2fat(sbi
, ts
, &time
, &date
, &time_cs
);
1156 de
= (struct msdos_dir_entry
*)bhs
[0]->b_data
;
1157 /* filling the new directory slots ("." and ".." entries) */
1158 memcpy(de
[0].name
, MSDOS_DOT
, MSDOS_NAME
);
1159 memcpy(de
[1].name
, MSDOS_DOTDOT
, MSDOS_NAME
);
1160 de
->attr
= de
[1].attr
= ATTR_DIR
;
1161 de
[0].lcase
= de
[1].lcase
= 0;
1162 de
[0].time
= de
[1].time
= time
;
1163 de
[0].date
= de
[1].date
= date
;
1164 if (sbi
->options
.isvfat
) {
1165 /* extra timestamps */
1166 de
[0].ctime
= de
[1].ctime
= time
;
1167 de
[0].ctime_cs
= de
[1].ctime_cs
= time_cs
;
1168 de
[0].adate
= de
[0].cdate
= de
[1].adate
= de
[1].cdate
= date
;
1170 de
[0].ctime
= de
[1].ctime
= 0;
1171 de
[0].ctime_cs
= de
[1].ctime_cs
= 0;
1172 de
[0].adate
= de
[0].cdate
= de
[1].adate
= de
[1].cdate
= 0;
1174 fat_set_start(&de
[0], cluster
);
1175 fat_set_start(&de
[1], MSDOS_I(dir
)->i_logstart
);
1176 de
[0].size
= de
[1].size
= 0;
1177 memset(de
+ 2, 0, sb
->s_blocksize
- 2 * sizeof(*de
));
1178 set_buffer_uptodate(bhs
[0]);
1179 mark_buffer_dirty_inode(bhs
[0], dir
);
1181 err
= fat_zeroed_cluster(dir
, blknr
, 1, bhs
, MAX_BUF_PER_PAGE
);
1188 fat_free_clusters(dir
, cluster
);
1192 EXPORT_SYMBOL_GPL(fat_alloc_new_dir
);
1194 static int fat_add_new_entries(struct inode
*dir
, void *slots
, int nr_slots
,
1195 int *nr_cluster
, struct msdos_dir_entry
**de
,
1196 struct buffer_head
**bh
, loff_t
*i_pos
)
1198 struct super_block
*sb
= dir
->i_sb
;
1199 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
1200 struct buffer_head
*bhs
[MAX_BUF_PER_PAGE
];
1201 sector_t blknr
, start_blknr
, last_blknr
;
1202 unsigned long size
, copy
;
1203 int err
, i
, n
, offset
, cluster
[2];
1206 * The minimum cluster size is 512bytes, and maximum entry
1207 * size is 32*slots (672bytes). So, iff the cluster size is
1208 * 512bytes, we may need two clusters.
1210 size
= nr_slots
* sizeof(struct msdos_dir_entry
);
1211 *nr_cluster
= (size
+ (sbi
->cluster_size
- 1)) >> sbi
->cluster_bits
;
1212 BUG_ON(*nr_cluster
> 2);
1214 err
= fat_alloc_clusters(dir
, cluster
, *nr_cluster
);
1219 * First stage: Fill the directory entry. NOTE: This cluster
1220 * is not referenced from any inode yet, so updates order is
1225 start_blknr
= blknr
= fat_clus_to_blknr(sbi
, cluster
[i
]);
1226 last_blknr
= start_blknr
+ sbi
->sec_per_clus
;
1227 while (blknr
< last_blknr
) {
1228 bhs
[n
] = sb_getblk(sb
, blknr
);
1234 /* fill the directory entry */
1235 copy
= min(size
, sb
->s_blocksize
);
1236 memcpy(bhs
[n
]->b_data
, slots
, copy
);
1239 set_buffer_uptodate(bhs
[n
]);
1240 mark_buffer_dirty_inode(bhs
[n
], dir
);
1246 } while (++i
< *nr_cluster
);
1248 memset(bhs
[n
]->b_data
+ copy
, 0, sb
->s_blocksize
- copy
);
1249 offset
= copy
- sizeof(struct msdos_dir_entry
);
1252 *de
= (struct msdos_dir_entry
*)((*bh
)->b_data
+ offset
);
1253 *i_pos
= fat_make_i_pos(sb
, *bh
, *de
);
1255 /* Second stage: clear the rest of cluster, and write outs */
1256 err
= fat_zeroed_cluster(dir
, start_blknr
, ++n
, bhs
, MAX_BUF_PER_PAGE
);
1267 for (i
= 0; i
< n
; i
++)
1269 fat_free_clusters(dir
, cluster
[0]);
1274 int fat_add_entries(struct inode
*dir
, void *slots
, int nr_slots
,
1275 struct fat_slot_info
*sinfo
)
1277 struct super_block
*sb
= dir
->i_sb
;
1278 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
1279 struct buffer_head
*bh
, *prev
, *bhs
[3]; /* 32*slots (672bytes) */
1280 struct msdos_dir_entry
*uninitialized_var(de
);
1281 int err
, free_slots
, i
, nr_bhs
;
1284 sinfo
->nr_slots
= nr_slots
;
1286 /* First stage: search free directory entries */
1287 free_slots
= nr_bhs
= 0;
1291 while (fat_get_entry(dir
, &pos
, &bh
, &de
) > -1) {
1292 /* check the maximum size of directory */
1293 if (pos
>= FAT_MAX_DIR_SIZE
)
1296 if (IS_FREE(de
->name
)) {
1299 bhs
[nr_bhs
] = prev
= bh
;
1303 if (free_slots
== nr_slots
)
1306 for (i
= 0; i
< nr_bhs
; i
++)
1309 free_slots
= nr_bhs
= 0;
1312 if (dir
->i_ino
== MSDOS_ROOT_INO
) {
1313 if (sbi
->fat_bits
!= 32)
1315 } else if (MSDOS_I(dir
)->i_start
== 0) {
1316 fat_msg(sb
, KERN_ERR
, "Corrupted directory (i_pos %lld)",
1317 MSDOS_I(dir
)->i_pos
);
1324 pos
-= free_slots
* sizeof(*de
);
1325 nr_slots
-= free_slots
;
1328 * Second stage: filling the free entries with new entries.
1329 * NOTE: If this slots has shortname, first, we write
1330 * the long name slots, then write the short name.
1332 int size
= free_slots
* sizeof(*de
);
1333 int offset
= pos
& (sb
->s_blocksize
- 1);
1334 int long_bhs
= nr_bhs
- (nr_slots
== 0);
1336 /* Fill the long name slots. */
1337 for (i
= 0; i
< long_bhs
; i
++) {
1338 int copy
= min_t(int, sb
->s_blocksize
- offset
, size
);
1339 memcpy(bhs
[i
]->b_data
+ offset
, slots
, copy
);
1340 mark_buffer_dirty_inode(bhs
[i
], dir
);
1345 if (long_bhs
&& IS_DIRSYNC(dir
))
1346 err
= fat_sync_bhs(bhs
, long_bhs
);
1347 if (!err
&& i
< nr_bhs
) {
1348 /* Fill the short name slot. */
1349 int copy
= min_t(int, sb
->s_blocksize
- offset
, size
);
1350 memcpy(bhs
[i
]->b_data
+ offset
, slots
, copy
);
1351 mark_buffer_dirty_inode(bhs
[i
], dir
);
1352 if (IS_DIRSYNC(dir
))
1353 err
= sync_dirty_buffer(bhs
[i
]);
1355 for (i
= 0; i
< nr_bhs
; i
++)
1362 int cluster
, nr_cluster
;
1365 * Third stage: allocate the cluster for new entries.
1366 * And initialize the cluster with new entries, then
1367 * add the cluster to dir.
1369 cluster
= fat_add_new_entries(dir
, slots
, nr_slots
, &nr_cluster
,
1375 err
= fat_chain_add(dir
, cluster
, nr_cluster
);
1377 fat_free_clusters(dir
, cluster
);
1380 if (dir
->i_size
& (sbi
->cluster_size
- 1)) {
1381 fat_fs_error(sb
, "Odd directory size");
1382 dir
->i_size
= (dir
->i_size
+ sbi
->cluster_size
- 1)
1383 & ~((loff_t
)sbi
->cluster_size
- 1);
1385 dir
->i_size
+= nr_cluster
<< sbi
->cluster_bits
;
1386 MSDOS_I(dir
)->mmu_private
+= nr_cluster
<< sbi
->cluster_bits
;
1388 sinfo
->slot_off
= pos
;
1391 sinfo
->i_pos
= fat_make_i_pos(sb
, sinfo
->bh
, sinfo
->de
);
1397 for (i
= 0; i
< nr_bhs
; i
++)
1404 __fat_remove_entries(dir
, pos
, free_slots
);
1407 EXPORT_SYMBOL_GPL(fat_add_entries
);