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
;
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
);
696 if (err
== -ENOENT
) {
703 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
706 err
= PTR_ERR(inode
);
709 alias
= d_find_alias(inode
);
711 if (d_invalidate(alias
) == 0)
722 dentry
->d_op
= &vfat_dentry_ops
[table
];
723 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
724 dentry
= d_splice_alias(inode
, dentry
);
726 dentry
->d_op
= &vfat_dentry_ops
[table
];
727 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
736 static int vfat_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
737 struct nameidata
*nd
)
739 struct super_block
*sb
= dir
->i_sb
;
741 struct fat_slot_info sinfo
;
747 ts
= CURRENT_TIME_SEC
;
748 err
= vfat_add_entry(dir
, &dentry
->d_name
, 0, 0, &ts
, &sinfo
);
753 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
756 err
= PTR_ERR(inode
);
760 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
761 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
763 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
764 d_instantiate(dentry
, inode
);
770 static int vfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
772 struct inode
*inode
= dentry
->d_inode
;
773 struct super_block
*sb
= dir
->i_sb
;
774 struct fat_slot_info sinfo
;
779 err
= fat_dir_empty(inode
);
782 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
786 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
792 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
800 static int vfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
802 struct inode
*inode
= dentry
->d_inode
;
803 struct super_block
*sb
= dir
->i_sb
;
804 struct fat_slot_info sinfo
;
809 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
813 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
817 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
825 static int vfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
827 struct super_block
*sb
= dir
->i_sb
;
829 struct fat_slot_info sinfo
;
835 ts
= CURRENT_TIME_SEC
;
836 cluster
= fat_alloc_new_dir(dir
, &ts
);
841 err
= vfat_add_entry(dir
, &dentry
->d_name
, 1, cluster
, &ts
, &sinfo
);
847 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
850 err
= PTR_ERR(inode
);
851 /* the directory was completed, just return a error */
856 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
857 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
859 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
860 d_instantiate(dentry
, inode
);
866 fat_free_clusters(dir
, cluster
);
872 static int vfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
873 struct inode
*new_dir
, struct dentry
*new_dentry
)
875 struct buffer_head
*dotdot_bh
;
876 struct msdos_dir_entry
*dotdot_de
;
877 struct inode
*old_inode
, *new_inode
;
878 struct fat_slot_info old_sinfo
, sinfo
;
880 loff_t dotdot_i_pos
, new_i_pos
;
881 int err
, is_dir
, update_dotdot
, corrupt
= 0;
882 struct super_block
*sb
= old_dir
->i_sb
;
884 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
885 old_inode
= old_dentry
->d_inode
;
886 new_inode
= new_dentry
->d_inode
;
888 err
= vfat_find(old_dir
, &old_dentry
->d_name
, &old_sinfo
);
892 is_dir
= S_ISDIR(old_inode
->i_mode
);
893 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
895 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
896 &dotdot_i_pos
) < 0) {
902 ts
= CURRENT_TIME_SEC
;
905 err
= fat_dir_empty(new_inode
);
909 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
910 fat_detach(new_inode
);
912 err
= vfat_add_entry(new_dir
, &new_dentry
->d_name
, is_dir
, 0,
916 new_i_pos
= sinfo
.i_pos
;
918 new_dir
->i_version
++;
920 fat_detach(old_inode
);
921 fat_attach(old_inode
, new_i_pos
);
922 if (IS_DIRSYNC(new_dir
)) {
923 err
= fat_sync_inode(old_inode
);
927 mark_inode_dirty(old_inode
);
930 int start
= MSDOS_I(new_dir
)->i_logstart
;
931 dotdot_de
->start
= cpu_to_le16(start
);
932 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
933 mark_buffer_dirty(dotdot_bh
);
934 if (IS_DIRSYNC(new_dir
)) {
935 err
= sync_dirty_buffer(dotdot_bh
);
944 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
948 old_dir
->i_version
++;
949 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
950 if (IS_DIRSYNC(old_dir
))
951 (void)fat_sync_inode(old_dir
);
953 mark_inode_dirty(old_dir
);
956 drop_nlink(new_inode
);
958 drop_nlink(new_inode
);
959 new_inode
->i_ctime
= ts
;
964 brelse(old_sinfo
.bh
);
970 /* data cluster is shared, serious corruption */
974 int start
= MSDOS_I(old_dir
)->i_logstart
;
975 dotdot_de
->start
= cpu_to_le16(start
);
976 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
977 mark_buffer_dirty(dotdot_bh
);
978 corrupt
|= sync_dirty_buffer(dotdot_bh
);
981 fat_detach(old_inode
);
982 fat_attach(old_inode
, old_sinfo
.i_pos
);
984 fat_attach(new_inode
, new_i_pos
);
986 corrupt
|= fat_sync_inode(new_inode
);
989 * If new entry was not sharing the data cluster, it
990 * shouldn't be serious corruption.
992 int err2
= fat_remove_entries(new_dir
, &sinfo
);
998 fat_fs_panic(new_dir
->i_sb
,
999 "%s: Filesystem corrupted (i_pos %lld)",
1000 __func__
, sinfo
.i_pos
);
1005 static const struct inode_operations vfat_dir_inode_operations
= {
1006 .create
= vfat_create
,
1007 .lookup
= vfat_lookup
,
1008 .unlink
= vfat_unlink
,
1009 .mkdir
= vfat_mkdir
,
1010 .rmdir
= vfat_rmdir
,
1011 .rename
= vfat_rename
,
1012 .setattr
= fat_setattr
,
1013 .getattr
= fat_getattr
,
1016 static int vfat_fill_super(struct super_block
*sb
, void *data
, int silent
)
1020 res
= fat_fill_super(sb
, data
, silent
, &vfat_dir_inode_operations
, 1);
1024 if (MSDOS_SB(sb
)->options
.name_check
!= 's')
1025 sb
->s_root
->d_op
= &vfat_dentry_ops
[0];
1027 sb
->s_root
->d_op
= &vfat_dentry_ops
[2];
1032 static int vfat_get_sb(struct file_system_type
*fs_type
,
1033 int flags
, const char *dev_name
,
1034 void *data
, struct vfsmount
*mnt
)
1036 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, vfat_fill_super
,
1040 static struct file_system_type vfat_fs_type
= {
1041 .owner
= THIS_MODULE
,
1043 .get_sb
= vfat_get_sb
,
1044 .kill_sb
= kill_block_super
,
1045 .fs_flags
= FS_REQUIRES_DEV
,
1048 static int __init
init_vfat_fs(void)
1050 return register_filesystem(&vfat_fs_type
);
1053 static void __exit
exit_vfat_fs(void)
1055 unregister_filesystem(&vfat_fs_type
);
1058 MODULE_LICENSE("GPL");
1059 MODULE_DESCRIPTION("VFAT filesystem support");
1060 MODULE_AUTHOR("Gordon Chaffee");
1062 module_init(init_vfat_fs
)
1063 module_exit(exit_vfat_fs
)