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/buffer_head.h>
23 #include <linux/namei.h>
27 * If new entry was created in the parent, it could create the 8.3
28 * alias (the shortname of logname). So, the parent may have the
29 * negative-dentry which matches the created 8.3 alias.
31 * If it happened, the negative dentry isn't actually negative
32 * anymore. So, drop it.
34 static int vfat_revalidate_shortname(struct dentry
*dentry
)
37 spin_lock(&dentry
->d_lock
);
38 if (dentry
->d_time
!= dentry
->d_parent
->d_inode
->i_version
)
40 spin_unlock(&dentry
->d_lock
);
44 static int vfat_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
46 /* This is not negative dentry. Always valid. */
49 return vfat_revalidate_shortname(dentry
);
52 static int vfat_revalidate_ci(struct dentry
*dentry
, struct nameidata
*nd
)
55 * This is not negative dentry. Always valid.
57 * Note, rename() to existing directory entry will have ->d_inode,
58 * and will use existing name which isn't specified name by user.
60 * We may be able to drop this positive dentry here. But dropping
61 * positive dentry isn't good idea. So it's unsupported like
62 * rename("filename", "FILENAME") for now.
68 * This may be nfsd (or something), anyway, we can't see the
69 * intent of this. So, since this can be for creation, drop it.
75 * Drop the negative dentry, in order to make sure to use the
76 * case sensitive name which is specified by user if this is
79 if (!(nd
->flags
& (LOOKUP_CONTINUE
| LOOKUP_PARENT
))) {
80 if (nd
->flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
84 return vfat_revalidate_shortname(dentry
);
87 /* returns the length of a struct qstr, ignoring trailing dots */
88 static unsigned int __vfat_striptail_len(unsigned int len
, const char *name
)
90 while (len
&& name
[len
- 1] == '.')
95 static unsigned int vfat_striptail_len(const struct qstr
*qstr
)
97 return __vfat_striptail_len(qstr
->len
, qstr
->name
);
101 * Compute the hash for the vfat name corresponding to the dentry.
102 * Note: if the name is invalid, we leave the hash code unchanged so
103 * that the existing dentry can be used. The vfat fs routines will
104 * return ENOENT or EINVAL as appropriate.
106 static int vfat_hash(const struct dentry
*dentry
, const struct inode
*inode
,
109 qstr
->hash
= full_name_hash(qstr
->name
, vfat_striptail_len(qstr
));
114 * Compute the hash for the vfat name corresponding to the dentry.
115 * Note: if the name is invalid, we leave the hash code unchanged so
116 * that the existing dentry can be used. The vfat fs routines will
117 * return ENOENT or EINVAL as appropriate.
119 static int vfat_hashi(const struct dentry
*dentry
, const struct inode
*inode
,
122 struct nls_table
*t
= MSDOS_SB(dentry
->d_sb
)->nls_io
;
123 const unsigned char *name
;
128 len
= vfat_striptail_len(qstr
);
130 hash
= init_name_hash();
132 hash
= partial_name_hash(nls_tolower(t
, *name
++), hash
);
133 qstr
->hash
= end_name_hash(hash
);
139 * Case insensitive compare of two vfat names.
141 static int vfat_cmpi(const struct dentry
*parent
, const struct inode
*pinode
,
142 const struct dentry
*dentry
, const struct inode
*inode
,
143 unsigned int len
, const char *str
, const struct qstr
*name
)
145 struct nls_table
*t
= MSDOS_SB(parent
->d_sb
)->nls_io
;
146 unsigned int alen
, blen
;
148 /* A filename cannot end in '.' or we treat it like it has none */
149 alen
= vfat_striptail_len(name
);
150 blen
= __vfat_striptail_len(len
, str
);
152 if (nls_strnicmp(t
, name
->name
, str
, alen
) == 0)
159 * Case sensitive compare of two vfat names.
161 static int vfat_cmp(const struct dentry
*parent
, const struct inode
*pinode
,
162 const struct dentry
*dentry
, const struct inode
*inode
,
163 unsigned int len
, const char *str
, const struct qstr
*name
)
165 unsigned int alen
, blen
;
167 /* A filename cannot end in '.' or we treat it like it has none */
168 alen
= vfat_striptail_len(name
);
169 blen
= __vfat_striptail_len(len
, str
);
171 if (strncmp(name
->name
, str
, alen
) == 0)
177 static const struct dentry_operations vfat_ci_dentry_ops
= {
178 .d_revalidate
= vfat_revalidate_ci
,
179 .d_hash
= vfat_hashi
,
180 .d_compare
= vfat_cmpi
,
183 static const struct dentry_operations vfat_dentry_ops
= {
184 .d_revalidate
= vfat_revalidate
,
186 .d_compare
= vfat_cmp
,
189 /* Characters that are undesirable in an MS-DOS file name */
191 static inline wchar_t vfat_bad_char(wchar_t w
)
194 || (w
== '*') || (w
== '?') || (w
== '<') || (w
== '>')
195 || (w
== '|') || (w
== '"') || (w
== ':') || (w
== '/')
199 static inline wchar_t vfat_replace_char(wchar_t w
)
201 return (w
== '[') || (w
== ']') || (w
== ';') || (w
== ',')
202 || (w
== '+') || (w
== '=');
205 static wchar_t vfat_skip_char(wchar_t w
)
207 return (w
== '.') || (w
== ' ');
210 static inline int vfat_is_used_badchars(const wchar_t *s
, int len
)
214 for (i
= 0; i
< len
; i
++)
215 if (vfat_bad_char(s
[i
]))
218 if (s
[i
- 1] == ' ') /* last character cannot be space */
224 static int vfat_find_form(struct inode
*dir
, unsigned char *name
)
226 struct fat_slot_info sinfo
;
227 int err
= fat_scan(dir
, name
, &sinfo
);
235 * 1) Valid characters for the 8.3 format alias are any combination of
236 * letters, uppercase alphabets, digits, any of the
237 * following special characters:
238 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
239 * In this case Longfilename is not stored in disk.
242 * File name and extension name is contain uppercase/lowercase
243 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
245 * 2) File name is 8.3 format, but it contain the uppercase and
246 * lowercase char, muliti bytes char, etc. In this case numtail is not
247 * added, but Longfilename is stored.
249 * 3) When the one except for the above, or the following special
250 * character are contained:
252 * numtail is added, and Longfilename must be stored in disk .
254 struct shortname_info
{
255 unsigned char lower
:1,
259 #define INIT_SHORTNAME_INFO(x) do { \
265 static inline int to_shortname_char(struct nls_table
*nls
,
266 unsigned char *buf
, int buf_size
,
267 wchar_t *src
, struct shortname_info
*info
)
271 if (vfat_skip_char(*src
)) {
275 if (vfat_replace_char(*src
)) {
281 len
= nls
->uni2char(*src
, buf
, buf_size
);
286 } else if (len
== 1) {
287 unsigned char prev
= buf
[0];
289 if (buf
[0] >= 0x7F) {
294 buf
[0] = nls_toupper(nls
, buf
[0]);
295 if (isalpha(buf
[0])) {
310 * Given a valid longname, create a unique shortname. Make sure the
311 * shortname does not exist
312 * Returns negative number on error, 0 for a normal
313 * return, and 1 for valid shortname
315 static int vfat_create_shortname(struct inode
*dir
, struct nls_table
*nls
,
316 wchar_t *uname
, int ulen
,
317 unsigned char *name_res
, unsigned char *lcase
)
319 struct fat_mount_options
*opts
= &MSDOS_SB(dir
->i_sb
)->options
;
320 wchar_t *ip
, *ext_start
, *end
, *name_start
;
321 unsigned char base
[9], ext
[4], buf
[5], *p
;
322 unsigned char charbuf
[NLS_MAX_CHARSET_SIZE
];
324 int sz
= 0, extlen
, baselen
, i
, numtail_baselen
, numtail2_baselen
;
326 struct shortname_info base_info
, ext_info
;
329 INIT_SHORTNAME_INFO(&base_info
);
330 INIT_SHORTNAME_INFO(&ext_info
);
332 /* Now, we need to create a shortname from the long name */
333 ext_start
= end
= &uname
[ulen
];
334 while (--ext_start
>= uname
) {
335 if (*ext_start
== 0x002E) { /* is `.' */
336 if (ext_start
== end
- 1) {
344 if (ext_start
== uname
- 1) {
347 } else if (ext_start
) {
349 * Names which start with a dot could be just
350 * an extension eg. "...test". In this case Win95
351 * uses the extension as the name and sets no extension.
353 name_start
= &uname
[0];
354 while (name_start
< ext_start
) {
355 if (!vfat_skip_char(*name_start
))
359 if (name_start
!= ext_start
) {
360 sz
= ext_start
- uname
;
369 numtail2_baselen
= 2;
370 for (baselen
= i
= 0, p
= base
, ip
= uname
; i
< sz
; i
++, ip
++) {
371 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
376 if (baselen
< 2 && (baselen
+ chl
) > 2)
377 numtail2_baselen
= baselen
;
378 if (baselen
< 6 && (baselen
+ chl
) > 6)
379 numtail_baselen
= baselen
;
380 for (chi
= 0; chi
< chl
; chi
++) {
387 if ((chi
< chl
- 1) || (ip
+ 1) - uname
< sz
)
398 for (p
= ext
, ip
= ext_start
; extlen
< 3 && ip
< end
; ip
++) {
399 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
404 if ((extlen
+ chl
) > 3) {
408 for (chi
= 0; chi
< chl
; chi
++) {
420 base
[baselen
] = '\0';
422 /* Yes, it can happen. ".\xe5" would do it. */
423 if (base
[0] == DELETED_FLAG
)
426 /* OK, at this point we know that base is not longer than 8 symbols,
427 * ext is not longer than 3, base is nonempty, both don't contain
428 * any bad symbols (lowercase transformed to uppercase).
431 memset(name_res
, ' ', MSDOS_NAME
);
432 memcpy(name_res
, base
, baselen
);
433 memcpy(name_res
+ 8, ext
, extlen
);
435 if (is_shortname
&& base_info
.valid
&& ext_info
.valid
) {
436 if (vfat_find_form(dir
, name_res
) == 0)
439 if (opts
->shortname
& VFAT_SFN_CREATE_WIN95
) {
440 return (base_info
.upper
&& ext_info
.upper
);
441 } else if (opts
->shortname
& VFAT_SFN_CREATE_WINNT
) {
442 if ((base_info
.upper
|| base_info
.lower
) &&
443 (ext_info
.upper
|| ext_info
.lower
)) {
444 if (!base_info
.upper
&& base_info
.lower
)
445 *lcase
|= CASE_LOWER_BASE
;
446 if (!ext_info
.upper
&& ext_info
.lower
)
447 *lcase
|= CASE_LOWER_EXT
;
456 if (opts
->numtail
== 0)
457 if (vfat_find_form(dir
, name_res
) < 0)
461 * Try to find a unique extension. This used to
462 * iterate through all possibilities sequentially,
463 * but that gave extremely bad performance. Windows
464 * only tries a few cases before using random
465 * values for part of the base.
469 baselen
= numtail_baselen
;
472 name_res
[baselen
] = '~';
473 for (i
= 1; i
< 10; i
++) {
474 name_res
[baselen
+ 1] = i
+ '0';
475 if (vfat_find_form(dir
, name_res
) < 0)
480 sz
= (jiffies
>> 16) & 0x7;
482 baselen
= numtail2_baselen
;
485 name_res
[baselen
+ 4] = '~';
486 name_res
[baselen
+ 5] = '1' + sz
;
488 snprintf(buf
, sizeof(buf
), "%04X", i
& 0xffff);
489 memcpy(&name_res
[baselen
], buf
, 4);
490 if (vfat_find_form(dir
, name_res
) < 0)
497 /* Translate a string, including coded sequences into Unicode */
499 xlate_to_uni(const unsigned char *name
, int len
, unsigned char *outname
,
500 int *longlen
, int *outlen
, int escape
, int utf8
,
501 struct nls_table
*nls
)
503 const unsigned char *ip
;
511 *outlen
= utf8s_to_utf16s(name
, len
, (wchar_t *)outname
);
514 else if (*outlen
> FAT_LFN_LEN
)
515 return -ENAMETOOLONG
;
517 op
= &outname
[*outlen
* sizeof(wchar_t)];
520 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
521 i
< len
&& *outlen
<= FAT_LFN_LEN
;
524 if (escape
&& (*ip
== ':')) {
528 for (k
= 1; k
< 5; k
++) {
531 if (nc
>= '0' && nc
<= '9') {
535 if (nc
>= 'a' && nc
<= 'f') {
536 ec
|= nc
- ('a' - 10);
539 if (nc
>= 'A' && nc
<= 'F') {
540 ec
|= nc
- ('A' - 10);
550 if ((charlen
= nls
->char2uni(ip
, len
- i
, (wchar_t *)op
)) < 0)
558 return -ENAMETOOLONG
;
560 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
561 i
< len
&& *outlen
<= FAT_LFN_LEN
;
568 return -ENAMETOOLONG
;
578 fill
= 13 - (*outlen
% 13);
579 for (i
= 0; i
< fill
; i
++) {
590 static int vfat_build_slots(struct inode
*dir
, const unsigned char *name
,
591 int len
, int is_dir
, int cluster
,
593 struct msdos_dir_slot
*slots
, int *nr_slots
)
595 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
596 struct fat_mount_options
*opts
= &sbi
->options
;
597 struct msdos_dir_slot
*ps
;
598 struct msdos_dir_entry
*de
;
599 unsigned char cksum
, lcase
;
600 unsigned char msdos_name
[MSDOS_NAME
];
604 int err
, ulen
, usize
, i
;
613 err
= xlate_to_uni(name
, len
, (unsigned char *)uname
, &ulen
, &usize
,
614 opts
->unicode_xlate
, opts
->utf8
, sbi
->nls_io
);
618 err
= vfat_is_used_badchars(uname
, ulen
);
622 err
= vfat_create_shortname(dir
, sbi
->nls_disk
, uname
, ulen
,
627 de
= (struct msdos_dir_entry
*)slots
;
632 /* build the entry of long file name */
633 cksum
= fat_checksum(msdos_name
);
635 *nr_slots
= usize
/ 13;
636 for (ps
= slots
, i
= *nr_slots
; i
> 0; i
--, ps
++) {
640 ps
->alias_checksum
= cksum
;
642 offset
= (i
- 1) * 13;
643 fatwchar_to16(ps
->name0_4
, uname
+ offset
, 5);
644 fatwchar_to16(ps
->name5_10
, uname
+ offset
+ 5, 6);
645 fatwchar_to16(ps
->name11_12
, uname
+ offset
+ 11, 2);
648 de
= (struct msdos_dir_entry
*)ps
;
651 /* build the entry of 8.3 alias name */
653 memcpy(de
->name
, msdos_name
, MSDOS_NAME
);
654 de
->attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
656 fat_time_unix2fat(sbi
, ts
, &time
, &date
, &time_cs
);
657 de
->time
= de
->ctime
= time
;
658 de
->date
= de
->cdate
= de
->adate
= date
;
659 de
->ctime_cs
= time_cs
;
660 de
->start
= cpu_to_le16(cluster
);
661 de
->starthi
= cpu_to_le16(cluster
>> 16);
668 static int vfat_add_entry(struct inode
*dir
, struct qstr
*qname
, int is_dir
,
669 int cluster
, struct timespec
*ts
,
670 struct fat_slot_info
*sinfo
)
672 struct msdos_dir_slot
*slots
;
676 len
= vfat_striptail_len(qname
);
680 slots
= kmalloc(sizeof(*slots
) * MSDOS_SLOTS
, GFP_NOFS
);
684 err
= vfat_build_slots(dir
, qname
->name
, len
, is_dir
, cluster
, ts
,
689 err
= fat_add_entries(dir
, slots
, nr_slots
, sinfo
);
693 /* update timestamp */
694 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= *ts
;
696 (void)fat_sync_inode(dir
);
698 mark_inode_dirty(dir
);
704 static int vfat_find(struct inode
*dir
, struct qstr
*qname
,
705 struct fat_slot_info
*sinfo
)
707 unsigned int len
= vfat_striptail_len(qname
);
710 return fat_search_long(dir
, qname
->name
, len
, sinfo
);
714 * (nfsd's) anonymous disconnected dentry?
715 * NOTE: !IS_ROOT() is not anonymous (I.e. d_splice_alias() did the job).
717 static int vfat_d_anon_disconn(struct dentry
*dentry
)
719 return IS_ROOT(dentry
) && (dentry
->d_flags
& DCACHE_DISCONNECTED
);
722 static struct dentry
*vfat_lookup(struct inode
*dir
, struct dentry
*dentry
,
723 struct nameidata
*nd
)
725 struct super_block
*sb
= dir
->i_sb
;
726 struct fat_slot_info sinfo
;
728 struct dentry
*alias
;
733 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
735 if (err
== -ENOENT
) {
742 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
745 err
= PTR_ERR(inode
);
749 alias
= d_find_alias(inode
);
750 if (alias
&& !vfat_d_anon_disconn(alias
)) {
752 * This inode has non anonymous-DCACHE_DISCONNECTED
753 * dentry. This means, the user did ->lookup() by an
754 * another name (longname vs 8.3 alias of it) in past.
756 * Switch to new one for reason of locality if possible.
758 BUG_ON(d_unhashed(alias
));
759 if (!S_ISDIR(inode
->i_mode
))
760 d_move(alias
, dentry
);
769 d_set_d_op(dentry
, sb
->s_root
->d_op
);
770 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
771 dentry
= d_splice_alias(inode
, dentry
);
773 d_set_d_op(dentry
, sb
->s_root
->d_op
);
774 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
783 static int vfat_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
784 struct nameidata
*nd
)
786 struct super_block
*sb
= dir
->i_sb
;
788 struct fat_slot_info sinfo
;
794 ts
= CURRENT_TIME_SEC
;
795 err
= vfat_add_entry(dir
, &dentry
->d_name
, 0, 0, &ts
, &sinfo
);
800 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
803 err
= PTR_ERR(inode
);
807 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
808 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
810 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
811 d_instantiate(dentry
, inode
);
817 static int vfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
819 struct inode
*inode
= dentry
->d_inode
;
820 struct super_block
*sb
= dir
->i_sb
;
821 struct fat_slot_info sinfo
;
826 err
= fat_dir_empty(inode
);
829 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
833 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
839 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
847 static int vfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
849 struct inode
*inode
= dentry
->d_inode
;
850 struct super_block
*sb
= dir
->i_sb
;
851 struct fat_slot_info sinfo
;
856 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
860 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
864 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
872 static int vfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
874 struct super_block
*sb
= dir
->i_sb
;
876 struct fat_slot_info sinfo
;
882 ts
= CURRENT_TIME_SEC
;
883 cluster
= fat_alloc_new_dir(dir
, &ts
);
888 err
= vfat_add_entry(dir
, &dentry
->d_name
, 1, cluster
, &ts
, &sinfo
);
894 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
897 err
= PTR_ERR(inode
);
898 /* the directory was completed, just return a error */
903 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
904 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
906 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
907 d_instantiate(dentry
, inode
);
913 fat_free_clusters(dir
, cluster
);
919 static int vfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
920 struct inode
*new_dir
, struct dentry
*new_dentry
)
922 struct buffer_head
*dotdot_bh
;
923 struct msdos_dir_entry
*dotdot_de
;
924 struct inode
*old_inode
, *new_inode
;
925 struct fat_slot_info old_sinfo
, sinfo
;
927 loff_t dotdot_i_pos
, new_i_pos
;
928 int err
, is_dir
, update_dotdot
, corrupt
= 0;
929 struct super_block
*sb
= old_dir
->i_sb
;
931 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
932 old_inode
= old_dentry
->d_inode
;
933 new_inode
= new_dentry
->d_inode
;
935 err
= vfat_find(old_dir
, &old_dentry
->d_name
, &old_sinfo
);
939 is_dir
= S_ISDIR(old_inode
->i_mode
);
940 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
942 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
943 &dotdot_i_pos
) < 0) {
949 ts
= CURRENT_TIME_SEC
;
952 err
= fat_dir_empty(new_inode
);
956 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
957 fat_detach(new_inode
);
959 err
= vfat_add_entry(new_dir
, &new_dentry
->d_name
, is_dir
, 0,
963 new_i_pos
= sinfo
.i_pos
;
965 new_dir
->i_version
++;
967 fat_detach(old_inode
);
968 fat_attach(old_inode
, new_i_pos
);
969 if (IS_DIRSYNC(new_dir
)) {
970 err
= fat_sync_inode(old_inode
);
974 mark_inode_dirty(old_inode
);
977 int start
= MSDOS_I(new_dir
)->i_logstart
;
978 dotdot_de
->start
= cpu_to_le16(start
);
979 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
980 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
981 if (IS_DIRSYNC(new_dir
)) {
982 err
= sync_dirty_buffer(dotdot_bh
);
991 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
995 old_dir
->i_version
++;
996 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
997 if (IS_DIRSYNC(old_dir
))
998 (void)fat_sync_inode(old_dir
);
1000 mark_inode_dirty(old_dir
);
1003 drop_nlink(new_inode
);
1005 drop_nlink(new_inode
);
1006 new_inode
->i_ctime
= ts
;
1011 brelse(old_sinfo
.bh
);
1017 /* data cluster is shared, serious corruption */
1020 if (update_dotdot
) {
1021 int start
= MSDOS_I(old_dir
)->i_logstart
;
1022 dotdot_de
->start
= cpu_to_le16(start
);
1023 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
1024 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
1025 corrupt
|= sync_dirty_buffer(dotdot_bh
);
1028 fat_detach(old_inode
);
1029 fat_attach(old_inode
, old_sinfo
.i_pos
);
1031 fat_attach(new_inode
, new_i_pos
);
1033 corrupt
|= fat_sync_inode(new_inode
);
1036 * If new entry was not sharing the data cluster, it
1037 * shouldn't be serious corruption.
1039 int err2
= fat_remove_entries(new_dir
, &sinfo
);
1045 fat_fs_error(new_dir
->i_sb
,
1046 "%s: Filesystem corrupted (i_pos %lld)",
1047 __func__
, sinfo
.i_pos
);
1052 static const struct inode_operations vfat_dir_inode_operations
= {
1053 .create
= vfat_create
,
1054 .lookup
= vfat_lookup
,
1055 .unlink
= vfat_unlink
,
1056 .mkdir
= vfat_mkdir
,
1057 .rmdir
= vfat_rmdir
,
1058 .rename
= vfat_rename
,
1059 .setattr
= fat_setattr
,
1060 .getattr
= fat_getattr
,
1063 static int vfat_fill_super(struct super_block
*sb
, void *data
, int silent
)
1068 res
= fat_fill_super(sb
, data
, silent
, &vfat_dir_inode_operations
, 1);
1074 if (MSDOS_SB(sb
)->options
.name_check
!= 's')
1075 d_set_d_op(sb
->s_root
, &vfat_ci_dentry_ops
);
1077 d_set_d_op(sb
->s_root
, &vfat_dentry_ops
);
1083 static struct dentry
*vfat_mount(struct file_system_type
*fs_type
,
1084 int flags
, const char *dev_name
,
1087 return mount_bdev(fs_type
, flags
, dev_name
, data
, vfat_fill_super
);
1090 static struct file_system_type vfat_fs_type
= {
1091 .owner
= THIS_MODULE
,
1093 .mount
= vfat_mount
,
1094 .kill_sb
= kill_block_super
,
1095 .fs_flags
= FS_REQUIRES_DEV
,
1098 static int __init
init_vfat_fs(void)
1100 return register_filesystem(&vfat_fs_type
);
1103 static void __exit
exit_vfat_fs(void)
1105 unregister_filesystem(&vfat_fs_type
);
1108 MODULE_LICENSE("GPL");
1109 MODULE_DESCRIPTION("VFAT filesystem support");
1110 MODULE_AUTHOR("Gordon Chaffee");
1112 module_init(init_vfat_fs
)
1113 module_exit(exit_vfat_fs
)