2 * linux/fs/vfat/namei.c
4 * Written 1992,1993 by Werner Almesberger
6 * Windows95/Windows NT compatible extended MSDOS filesystem
7 * by Gordon Chaffee Copyright (C) 1995. Send bug reports for the
8 * VFAT filesystem to <chaffee@cs.berkeley.edu>. Specify
9 * what file operation caused you trouble and if you can duplicate
10 * the problem, send a script that demonstrates it.
12 * Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
14 * Support Multibyte characters and cleanup by
15 * OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
18 #include <linux/module.h>
19 #include <linux/jiffies.h>
20 #include <linux/ctype.h>
21 #include <linux/slab.h>
22 #include <linux/smp_lock.h>
23 #include <linux/buffer_head.h>
24 #include <linux/namei.h>
27 static int vfat_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
31 if (!dentry
->d_inode
&&
32 nd
&& !(nd
->flags
& LOOKUP_CONTINUE
) && (nd
->flags
& LOOKUP_CREATE
))
34 * negative dentry is dropped, in order to make sure
35 * to use the name which a user desires if this is
40 spin_lock(&dentry
->d_lock
);
41 if (dentry
->d_time
!= dentry
->d_parent
->d_inode
->i_version
)
43 spin_unlock(&dentry
->d_lock
);
48 /* returns the length of a struct qstr, ignoring trailing dots */
49 static unsigned int vfat_striptail_len(struct qstr
*qstr
)
51 unsigned int len
= qstr
->len
;
53 while (len
&& qstr
->name
[len
- 1] == '.')
59 * Compute the hash for the vfat name corresponding to the dentry.
60 * Note: if the name is invalid, we leave the hash code unchanged so
61 * that the existing dentry can be used. The vfat fs routines will
62 * return ENOENT or EINVAL as appropriate.
64 static int vfat_hash(struct dentry
*dentry
, struct qstr
*qstr
)
66 qstr
->hash
= full_name_hash(qstr
->name
, vfat_striptail_len(qstr
));
71 * Compute the hash for the vfat name corresponding to the dentry.
72 * Note: if the name is invalid, we leave the hash code unchanged so
73 * that the existing dentry can be used. The vfat fs routines will
74 * return ENOENT or EINVAL as appropriate.
76 static int vfat_hashi(struct dentry
*dentry
, struct qstr
*qstr
)
78 struct nls_table
*t
= MSDOS_SB(dentry
->d_inode
->i_sb
)->nls_io
;
79 const unsigned char *name
;
84 len
= vfat_striptail_len(qstr
);
86 hash
= init_name_hash();
88 hash
= partial_name_hash(nls_tolower(t
, *name
++), hash
);
89 qstr
->hash
= end_name_hash(hash
);
95 * Case insensitive compare of two vfat names.
97 static int vfat_cmpi(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
99 struct nls_table
*t
= MSDOS_SB(dentry
->d_inode
->i_sb
)->nls_io
;
100 unsigned int alen
, blen
;
102 /* A filename cannot end in '.' or we treat it like it has none */
103 alen
= vfat_striptail_len(a
);
104 blen
= vfat_striptail_len(b
);
106 if (nls_strnicmp(t
, a
->name
, b
->name
, alen
) == 0)
113 * Case sensitive compare of two vfat names.
115 static int vfat_cmp(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
117 unsigned int alen
, blen
;
119 /* A filename cannot end in '.' or we treat it like it has none */
120 alen
= vfat_striptail_len(a
);
121 blen
= vfat_striptail_len(b
);
123 if (strncmp(a
->name
, b
->name
, alen
) == 0)
129 static struct dentry_operations vfat_dentry_ops
[4] = {
131 .d_hash
= vfat_hashi
,
132 .d_compare
= vfat_cmpi
,
135 .d_revalidate
= vfat_revalidate
,
136 .d_hash
= vfat_hashi
,
137 .d_compare
= vfat_cmpi
,
141 .d_compare
= vfat_cmp
,
144 .d_revalidate
= vfat_revalidate
,
146 .d_compare
= vfat_cmp
,
150 /* Characters that are undesirable in an MS-DOS file name */
152 static inline wchar_t vfat_bad_char(wchar_t w
)
155 || (w
== '*') || (w
== '?') || (w
== '<') || (w
== '>')
156 || (w
== '|') || (w
== '"') || (w
== ':') || (w
== '/')
160 static inline wchar_t vfat_replace_char(wchar_t w
)
162 return (w
== '[') || (w
== ']') || (w
== ';') || (w
== ',')
163 || (w
== '+') || (w
== '=');
166 static wchar_t vfat_skip_char(wchar_t w
)
168 return (w
== '.') || (w
== ' ');
171 static inline int vfat_is_used_badchars(const wchar_t *s
, int len
)
175 for (i
= 0; i
< len
; i
++)
176 if (vfat_bad_char(s
[i
]))
179 if (s
[i
- 1] == ' ') /* last character cannot be space */
185 static int vfat_find_form(struct inode
*dir
, unsigned char *name
)
187 struct fat_slot_info sinfo
;
188 int err
= fat_scan(dir
, name
, &sinfo
);
196 * 1) Valid characters for the 8.3 format alias are any combination of
197 * letters, uppercase alphabets, digits, any of the
198 * following special characters:
199 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
200 * In this case Longfilename is not stored in disk.
203 * File name and extension name is contain uppercase/lowercase
204 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
206 * 2) File name is 8.3 format, but it contain the uppercase and
207 * lowercase char, muliti bytes char, etc. In this case numtail is not
208 * added, but Longfilename is stored.
210 * 3) When the one except for the above, or the following special
211 * character are contained:
213 * numtail is added, and Longfilename must be stored in disk .
215 struct shortname_info
{
216 unsigned char lower
:1,
220 #define INIT_SHORTNAME_INFO(x) do { \
226 static inline int to_shortname_char(struct nls_table
*nls
,
227 unsigned char *buf
, int buf_size
,
228 wchar_t *src
, struct shortname_info
*info
)
232 if (vfat_skip_char(*src
)) {
236 if (vfat_replace_char(*src
)) {
242 len
= nls
->uni2char(*src
, buf
, buf_size
);
247 } else if (len
== 1) {
248 unsigned char prev
= buf
[0];
250 if (buf
[0] >= 0x7F) {
255 buf
[0] = nls_toupper(nls
, buf
[0]);
256 if (isalpha(buf
[0])) {
271 * Given a valid longname, create a unique shortname. Make sure the
272 * shortname does not exist
273 * Returns negative number on error, 0 for a normal
274 * return, and 1 for valid shortname
276 static int vfat_create_shortname(struct inode
*dir
, struct nls_table
*nls
,
277 wchar_t *uname
, int ulen
,
278 unsigned char *name_res
, unsigned char *lcase
)
280 struct fat_mount_options
*opts
= &MSDOS_SB(dir
->i_sb
)->options
;
281 wchar_t *ip
, *ext_start
, *end
, *name_start
;
282 unsigned char base
[9], ext
[4], buf
[8], *p
;
283 unsigned char charbuf
[NLS_MAX_CHARSET_SIZE
];
285 int sz
= 0, extlen
, baselen
, i
, numtail_baselen
, numtail2_baselen
;
287 struct shortname_info base_info
, ext_info
;
290 INIT_SHORTNAME_INFO(&base_info
);
291 INIT_SHORTNAME_INFO(&ext_info
);
293 /* Now, we need to create a shortname from the long name */
294 ext_start
= end
= &uname
[ulen
];
295 while (--ext_start
>= uname
) {
296 if (*ext_start
== 0x002E) { /* is `.' */
297 if (ext_start
== end
- 1) {
305 if (ext_start
== uname
- 1) {
308 } else if (ext_start
) {
310 * Names which start with a dot could be just
311 * an extension eg. "...test". In this case Win95
312 * uses the extension as the name and sets no extension.
314 name_start
= &uname
[0];
315 while (name_start
< ext_start
) {
316 if (!vfat_skip_char(*name_start
))
320 if (name_start
!= ext_start
) {
321 sz
= ext_start
- uname
;
330 numtail2_baselen
= 2;
331 for (baselen
= i
= 0, p
= base
, ip
= uname
; i
< sz
; i
++, ip
++) {
332 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
337 if (baselen
< 2 && (baselen
+ chl
) > 2)
338 numtail2_baselen
= baselen
;
339 if (baselen
< 6 && (baselen
+ chl
) > 6)
340 numtail_baselen
= baselen
;
341 for (chi
= 0; chi
< chl
; chi
++) {
348 if ((chi
< chl
- 1) || (ip
+ 1) - uname
< sz
)
359 for (p
= ext
, ip
= ext_start
; extlen
< 3 && ip
< end
; ip
++) {
360 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
365 if ((extlen
+ chl
) > 3) {
369 for (chi
= 0; chi
< chl
; chi
++) {
381 base
[baselen
] = '\0';
383 /* Yes, it can happen. ".\xe5" would do it. */
384 if (base
[0] == DELETED_FLAG
)
387 /* OK, at this point we know that base is not longer than 8 symbols,
388 * ext is not longer than 3, base is nonempty, both don't contain
389 * any bad symbols (lowercase transformed to uppercase).
392 memset(name_res
, ' ', MSDOS_NAME
);
393 memcpy(name_res
, base
, baselen
);
394 memcpy(name_res
+ 8, ext
, extlen
);
396 if (is_shortname
&& base_info
.valid
&& ext_info
.valid
) {
397 if (vfat_find_form(dir
, name_res
) == 0)
400 if (opts
->shortname
& VFAT_SFN_CREATE_WIN95
) {
401 return (base_info
.upper
&& ext_info
.upper
);
402 } else if (opts
->shortname
& VFAT_SFN_CREATE_WINNT
) {
403 if ((base_info
.upper
|| base_info
.lower
) &&
404 (ext_info
.upper
|| ext_info
.lower
)) {
405 if (!base_info
.upper
&& base_info
.lower
)
406 *lcase
|= CASE_LOWER_BASE
;
407 if (!ext_info
.upper
&& ext_info
.lower
)
408 *lcase
|= CASE_LOWER_EXT
;
417 if (opts
->numtail
== 0)
418 if (vfat_find_form(dir
, name_res
) < 0)
422 * Try to find a unique extension. This used to
423 * iterate through all possibilities sequentially,
424 * but that gave extremely bad performance. Windows
425 * only tries a few cases before using random
426 * values for part of the base.
430 baselen
= numtail_baselen
;
433 name_res
[baselen
] = '~';
434 for (i
= 1; i
< 10; i
++) {
435 name_res
[baselen
+ 1] = i
+ '0';
436 if (vfat_find_form(dir
, name_res
) < 0)
440 i
= jiffies
& 0xffff;
441 sz
= (jiffies
>> 16) & 0x7;
443 baselen
= numtail2_baselen
;
446 name_res
[baselen
+ 4] = '~';
447 name_res
[baselen
+ 5] = '1' + sz
;
449 sprintf(buf
, "%04X", i
);
450 memcpy(&name_res
[baselen
], buf
, 4);
451 if (vfat_find_form(dir
, name_res
) < 0)
458 /* Translate a string, including coded sequences into Unicode */
460 xlate_to_uni(const unsigned char *name
, int len
, unsigned char *outname
,
461 int *longlen
, int *outlen
, int escape
, int utf8
,
462 struct nls_table
*nls
)
464 const unsigned char *ip
;
472 int name_len
= strlen(name
);
474 *outlen
= utf8_mbstowcs((wchar_t *)outname
, name
, PATH_MAX
);
477 * We stripped '.'s before and set len appropriately,
478 * but utf8_mbstowcs doesn't care about len
480 *outlen
-= (name_len
- len
);
483 return -ENAMETOOLONG
;
485 op
= &outname
[*outlen
* sizeof(wchar_t)];
488 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
489 i
< len
&& *outlen
<= 255;
492 if (escape
&& (*ip
== ':')) {
496 for (k
= 1; k
< 5; k
++) {
499 if (nc
>= '0' && nc
<= '9') {
503 if (nc
>= 'a' && nc
<= 'f') {
504 ec
|= nc
- ('a' - 10);
507 if (nc
>= 'A' && nc
<= 'F') {
508 ec
|= nc
- ('A' - 10);
518 if ((charlen
= nls
->char2uni(ip
, len
- i
, (wchar_t *)op
)) < 0)
526 return -ENAMETOOLONG
;
528 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
529 i
< len
&& *outlen
<= 255;
536 return -ENAMETOOLONG
;
546 fill
= 13 - (*outlen
% 13);
547 for (i
= 0; i
< fill
; i
++) {
558 static int vfat_build_slots(struct inode
*dir
, const unsigned char *name
,
559 int len
, int is_dir
, int cluster
,
561 struct msdos_dir_slot
*slots
, int *nr_slots
)
563 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
564 struct fat_mount_options
*opts
= &sbi
->options
;
565 struct msdos_dir_slot
*ps
;
566 struct msdos_dir_entry
*de
;
567 unsigned char cksum
, lcase
;
568 unsigned char msdos_name
[MSDOS_NAME
];
572 int err
, ulen
, usize
, i
;
581 err
= xlate_to_uni(name
, len
, (unsigned char *)uname
, &ulen
, &usize
,
582 opts
->unicode_xlate
, opts
->utf8
, sbi
->nls_io
);
586 err
= vfat_is_used_badchars(uname
, ulen
);
590 err
= vfat_create_shortname(dir
, sbi
->nls_disk
, uname
, ulen
,
595 de
= (struct msdos_dir_entry
*)slots
;
600 /* build the entry of long file name */
601 cksum
= fat_checksum(msdos_name
);
603 *nr_slots
= usize
/ 13;
604 for (ps
= slots
, i
= *nr_slots
; i
> 0; i
--, ps
++) {
608 ps
->alias_checksum
= cksum
;
610 offset
= (i
- 1) * 13;
611 fatwchar_to16(ps
->name0_4
, uname
+ offset
, 5);
612 fatwchar_to16(ps
->name5_10
, uname
+ offset
+ 5, 6);
613 fatwchar_to16(ps
->name11_12
, uname
+ offset
+ 11, 2);
616 de
= (struct msdos_dir_entry
*)ps
;
619 /* build the entry of 8.3 alias name */
621 memcpy(de
->name
, msdos_name
, MSDOS_NAME
);
622 de
->attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
624 fat_time_unix2fat(sbi
, ts
, &time
, &date
, &time_cs
);
625 de
->time
= de
->ctime
= time
;
626 de
->date
= de
->cdate
= de
->adate
= date
;
627 de
->ctime_cs
= time_cs
;
628 de
->start
= cpu_to_le16(cluster
);
629 de
->starthi
= cpu_to_le16(cluster
>> 16);
636 static int vfat_add_entry(struct inode
*dir
, struct qstr
*qname
, int is_dir
,
637 int cluster
, struct timespec
*ts
,
638 struct fat_slot_info
*sinfo
)
640 struct msdos_dir_slot
*slots
;
644 len
= vfat_striptail_len(qname
);
648 slots
= kmalloc(sizeof(*slots
) * MSDOS_SLOTS
, GFP_NOFS
);
652 err
= vfat_build_slots(dir
, qname
->name
, len
, is_dir
, cluster
, ts
,
657 err
= fat_add_entries(dir
, slots
, nr_slots
, sinfo
);
661 /* update timestamp */
662 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= *ts
;
664 (void)fat_sync_inode(dir
);
666 mark_inode_dirty(dir
);
672 static int vfat_find(struct inode
*dir
, struct qstr
*qname
,
673 struct fat_slot_info
*sinfo
)
675 unsigned int len
= vfat_striptail_len(qname
);
678 return fat_search_long(dir
, qname
->name
, len
, sinfo
);
681 static struct dentry
*vfat_lookup(struct inode
*dir
, struct dentry
*dentry
,
682 struct nameidata
*nd
)
684 struct super_block
*sb
= dir
->i_sb
;
685 struct fat_slot_info sinfo
;
686 struct inode
*inode
= NULL
;
687 struct dentry
*alias
;
691 table
= (MSDOS_SB(sb
)->options
.name_check
== 's') ? 2 : 0;
692 dentry
->d_op
= &vfat_dentry_ops
[table
];
694 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
699 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
703 return ERR_CAST(inode
);
705 alias
= d_find_alias(inode
);
707 if (d_invalidate(alias
) == 0)
718 dentry
->d_op
= &vfat_dentry_ops
[table
];
719 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
720 dentry
= d_splice_alias(inode
, dentry
);
722 dentry
->d_op
= &vfat_dentry_ops
[table
];
723 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
728 static int vfat_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
729 struct nameidata
*nd
)
731 struct super_block
*sb
= dir
->i_sb
;
733 struct fat_slot_info sinfo
;
739 ts
= CURRENT_TIME_SEC
;
740 err
= vfat_add_entry(dir
, &dentry
->d_name
, 0, 0, &ts
, &sinfo
);
745 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
748 err
= PTR_ERR(inode
);
752 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
753 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
755 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
756 d_instantiate(dentry
, inode
);
762 static int vfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
764 struct inode
*inode
= dentry
->d_inode
;
765 struct super_block
*sb
= dir
->i_sb
;
766 struct fat_slot_info sinfo
;
771 err
= fat_dir_empty(inode
);
774 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
778 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
784 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
792 static int vfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
794 struct inode
*inode
= dentry
->d_inode
;
795 struct super_block
*sb
= dir
->i_sb
;
796 struct fat_slot_info sinfo
;
801 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
805 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
809 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
817 static int vfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
819 struct super_block
*sb
= dir
->i_sb
;
821 struct fat_slot_info sinfo
;
827 ts
= CURRENT_TIME_SEC
;
828 cluster
= fat_alloc_new_dir(dir
, &ts
);
833 err
= vfat_add_entry(dir
, &dentry
->d_name
, 1, cluster
, &ts
, &sinfo
);
839 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
842 err
= PTR_ERR(inode
);
843 /* the directory was completed, just return a error */
848 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
849 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
851 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
852 d_instantiate(dentry
, inode
);
858 fat_free_clusters(dir
, cluster
);
864 static int vfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
865 struct inode
*new_dir
, struct dentry
*new_dentry
)
867 struct buffer_head
*dotdot_bh
;
868 struct msdos_dir_entry
*dotdot_de
;
869 struct inode
*old_inode
, *new_inode
;
870 struct fat_slot_info old_sinfo
, sinfo
;
872 loff_t dotdot_i_pos
, new_i_pos
;
873 int err
, is_dir
, update_dotdot
, corrupt
= 0;
874 struct super_block
*sb
= old_dir
->i_sb
;
876 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
877 old_inode
= old_dentry
->d_inode
;
878 new_inode
= new_dentry
->d_inode
;
880 err
= vfat_find(old_dir
, &old_dentry
->d_name
, &old_sinfo
);
884 is_dir
= S_ISDIR(old_inode
->i_mode
);
885 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
887 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
888 &dotdot_i_pos
) < 0) {
894 ts
= CURRENT_TIME_SEC
;
897 err
= fat_dir_empty(new_inode
);
901 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
902 fat_detach(new_inode
);
904 err
= vfat_add_entry(new_dir
, &new_dentry
->d_name
, is_dir
, 0,
908 new_i_pos
= sinfo
.i_pos
;
910 new_dir
->i_version
++;
912 fat_detach(old_inode
);
913 fat_attach(old_inode
, new_i_pos
);
914 if (IS_DIRSYNC(new_dir
)) {
915 err
= fat_sync_inode(old_inode
);
919 mark_inode_dirty(old_inode
);
922 int start
= MSDOS_I(new_dir
)->i_logstart
;
923 dotdot_de
->start
= cpu_to_le16(start
);
924 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
925 mark_buffer_dirty(dotdot_bh
);
926 if (IS_DIRSYNC(new_dir
)) {
927 err
= sync_dirty_buffer(dotdot_bh
);
936 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
940 old_dir
->i_version
++;
941 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
942 if (IS_DIRSYNC(old_dir
))
943 (void)fat_sync_inode(old_dir
);
945 mark_inode_dirty(old_dir
);
948 drop_nlink(new_inode
);
950 drop_nlink(new_inode
);
951 new_inode
->i_ctime
= ts
;
956 brelse(old_sinfo
.bh
);
962 /* data cluster is shared, serious corruption */
966 int start
= MSDOS_I(old_dir
)->i_logstart
;
967 dotdot_de
->start
= cpu_to_le16(start
);
968 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
969 mark_buffer_dirty(dotdot_bh
);
970 corrupt
|= sync_dirty_buffer(dotdot_bh
);
973 fat_detach(old_inode
);
974 fat_attach(old_inode
, old_sinfo
.i_pos
);
976 fat_attach(new_inode
, new_i_pos
);
978 corrupt
|= fat_sync_inode(new_inode
);
981 * If new entry was not sharing the data cluster, it
982 * shouldn't be serious corruption.
984 int err2
= fat_remove_entries(new_dir
, &sinfo
);
990 fat_fs_panic(new_dir
->i_sb
,
991 "%s: Filesystem corrupted (i_pos %lld)",
992 __func__
, sinfo
.i_pos
);
997 static const struct inode_operations vfat_dir_inode_operations
= {
998 .create
= vfat_create
,
999 .lookup
= vfat_lookup
,
1000 .unlink
= vfat_unlink
,
1001 .mkdir
= vfat_mkdir
,
1002 .rmdir
= vfat_rmdir
,
1003 .rename
= vfat_rename
,
1004 .setattr
= fat_setattr
,
1005 .getattr
= fat_getattr
,
1008 static int vfat_fill_super(struct super_block
*sb
, void *data
, int silent
)
1012 res
= fat_fill_super(sb
, data
, silent
, &vfat_dir_inode_operations
, 1);
1016 if (MSDOS_SB(sb
)->options
.name_check
!= 's')
1017 sb
->s_root
->d_op
= &vfat_dentry_ops
[0];
1019 sb
->s_root
->d_op
= &vfat_dentry_ops
[2];
1024 static int vfat_get_sb(struct file_system_type
*fs_type
,
1025 int flags
, const char *dev_name
,
1026 void *data
, struct vfsmount
*mnt
)
1028 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, vfat_fill_super
,
1032 static struct file_system_type vfat_fs_type
= {
1033 .owner
= THIS_MODULE
,
1035 .get_sb
= vfat_get_sb
,
1036 .kill_sb
= kill_block_super
,
1037 .fs_flags
= FS_REQUIRES_DEV
,
1040 static int __init
init_vfat_fs(void)
1042 return register_filesystem(&vfat_fs_type
);
1045 static void __exit
exit_vfat_fs(void)
1047 unregister_filesystem(&vfat_fs_type
);
1050 MODULE_LICENSE("GPL");
1051 MODULE_DESCRIPTION("VFAT filesystem support");
1052 MODULE_AUTHOR("Gordon Chaffee");
1054 module_init(init_vfat_fs
)
1055 module_exit(exit_vfat_fs
)