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
, unsigned int flags
)
46 if (flags
& LOOKUP_RCU
)
49 /* This is not negative dentry. Always valid. */
52 return vfat_revalidate_shortname(dentry
);
55 static int vfat_revalidate_ci(struct dentry
*dentry
, unsigned int flags
)
57 if (flags
& LOOKUP_RCU
)
61 * This is not negative dentry. Always valid.
63 * Note, rename() to existing directory entry will have ->d_inode,
64 * and will use existing name which isn't specified name by user.
66 * We may be able to drop this positive dentry here. But dropping
67 * positive dentry isn't good idea. So it's unsupported like
68 * rename("filename", "FILENAME") for now.
74 * This may be nfsd (or something), anyway, we can't see the
75 * intent of this. So, since this can be for creation, drop it.
81 * Drop the negative dentry, in order to make sure to use the
82 * case sensitive name which is specified by user if this is
85 if (flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
88 return vfat_revalidate_shortname(dentry
);
91 /* returns the length of a struct qstr, ignoring trailing dots */
92 static unsigned int __vfat_striptail_len(unsigned int len
, const char *name
)
94 while (len
&& name
[len
- 1] == '.')
99 static unsigned int vfat_striptail_len(const struct qstr
*qstr
)
101 return __vfat_striptail_len(qstr
->len
, qstr
->name
);
105 * Compute the hash for the vfat name corresponding to the dentry.
106 * Note: if the name is invalid, we leave the hash code unchanged so
107 * that the existing dentry can be used. The vfat fs routines will
108 * return ENOENT or EINVAL as appropriate.
110 static int vfat_hash(const struct dentry
*dentry
, const struct inode
*inode
,
113 qstr
->hash
= full_name_hash(qstr
->name
, vfat_striptail_len(qstr
));
118 * Compute the hash for the vfat name corresponding to the dentry.
119 * Note: if the name is invalid, we leave the hash code unchanged so
120 * that the existing dentry can be used. The vfat fs routines will
121 * return ENOENT or EINVAL as appropriate.
123 static int vfat_hashi(const struct dentry
*dentry
, const struct inode
*inode
,
126 struct nls_table
*t
= MSDOS_SB(dentry
->d_sb
)->nls_io
;
127 const unsigned char *name
;
132 len
= vfat_striptail_len(qstr
);
134 hash
= init_name_hash();
136 hash
= partial_name_hash(nls_tolower(t
, *name
++), hash
);
137 qstr
->hash
= end_name_hash(hash
);
143 * Case insensitive compare of two vfat names.
145 static int vfat_cmpi(const struct dentry
*parent
, const struct inode
*pinode
,
146 const struct dentry
*dentry
, const struct inode
*inode
,
147 unsigned int len
, const char *str
, const struct qstr
*name
)
149 struct nls_table
*t
= MSDOS_SB(parent
->d_sb
)->nls_io
;
150 unsigned int alen
, blen
;
152 /* A filename cannot end in '.' or we treat it like it has none */
153 alen
= vfat_striptail_len(name
);
154 blen
= __vfat_striptail_len(len
, str
);
156 if (nls_strnicmp(t
, name
->name
, str
, alen
) == 0)
163 * Case sensitive compare of two vfat names.
165 static int vfat_cmp(const struct dentry
*parent
, const struct inode
*pinode
,
166 const struct dentry
*dentry
, const struct inode
*inode
,
167 unsigned int len
, const char *str
, const struct qstr
*name
)
169 unsigned int alen
, blen
;
171 /* A filename cannot end in '.' or we treat it like it has none */
172 alen
= vfat_striptail_len(name
);
173 blen
= __vfat_striptail_len(len
, str
);
175 if (strncmp(name
->name
, str
, alen
) == 0)
181 static const struct dentry_operations vfat_ci_dentry_ops
= {
182 .d_revalidate
= vfat_revalidate_ci
,
183 .d_hash
= vfat_hashi
,
184 .d_compare
= vfat_cmpi
,
187 static const struct dentry_operations vfat_dentry_ops
= {
188 .d_revalidate
= vfat_revalidate
,
190 .d_compare
= vfat_cmp
,
193 /* Characters that are undesirable in an MS-DOS file name */
195 static inline wchar_t vfat_bad_char(wchar_t w
)
198 || (w
== '*') || (w
== '?') || (w
== '<') || (w
== '>')
199 || (w
== '|') || (w
== '"') || (w
== ':') || (w
== '/')
203 static inline wchar_t vfat_replace_char(wchar_t w
)
205 return (w
== '[') || (w
== ']') || (w
== ';') || (w
== ',')
206 || (w
== '+') || (w
== '=');
209 static wchar_t vfat_skip_char(wchar_t w
)
211 return (w
== '.') || (w
== ' ');
214 static inline int vfat_is_used_badchars(const wchar_t *s
, int len
)
218 for (i
= 0; i
< len
; i
++)
219 if (vfat_bad_char(s
[i
]))
222 if (s
[i
- 1] == ' ') /* last character cannot be space */
228 static int vfat_find_form(struct inode
*dir
, unsigned char *name
)
230 struct fat_slot_info sinfo
;
231 int err
= fat_scan(dir
, name
, &sinfo
);
239 * 1) Valid characters for the 8.3 format alias are any combination of
240 * letters, uppercase alphabets, digits, any of the
241 * following special characters:
242 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
243 * In this case Longfilename is not stored in disk.
246 * File name and extension name is contain uppercase/lowercase
247 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
249 * 2) File name is 8.3 format, but it contain the uppercase and
250 * lowercase char, muliti bytes char, etc. In this case numtail is not
251 * added, but Longfilename is stored.
253 * 3) When the one except for the above, or the following special
254 * character are contained:
256 * numtail is added, and Longfilename must be stored in disk .
258 struct shortname_info
{
259 unsigned char lower
:1,
263 #define INIT_SHORTNAME_INFO(x) do { \
269 static inline int to_shortname_char(struct nls_table
*nls
,
270 unsigned char *buf
, int buf_size
,
271 wchar_t *src
, struct shortname_info
*info
)
275 if (vfat_skip_char(*src
)) {
279 if (vfat_replace_char(*src
)) {
285 len
= nls
->uni2char(*src
, buf
, buf_size
);
290 } else if (len
== 1) {
291 unsigned char prev
= buf
[0];
293 if (buf
[0] >= 0x7F) {
298 buf
[0] = nls_toupper(nls
, buf
[0]);
299 if (isalpha(buf
[0])) {
314 * Given a valid longname, create a unique shortname. Make sure the
315 * shortname does not exist
316 * Returns negative number on error, 0 for a normal
317 * return, and 1 for valid shortname
319 static int vfat_create_shortname(struct inode
*dir
, struct nls_table
*nls
,
320 wchar_t *uname
, int ulen
,
321 unsigned char *name_res
, unsigned char *lcase
)
323 struct fat_mount_options
*opts
= &MSDOS_SB(dir
->i_sb
)->options
;
324 wchar_t *ip
, *ext_start
, *end
, *name_start
;
325 unsigned char base
[9], ext
[4], buf
[5], *p
;
326 unsigned char charbuf
[NLS_MAX_CHARSET_SIZE
];
328 int sz
= 0, extlen
, baselen
, i
, numtail_baselen
, numtail2_baselen
;
330 struct shortname_info base_info
, ext_info
;
333 INIT_SHORTNAME_INFO(&base_info
);
334 INIT_SHORTNAME_INFO(&ext_info
);
336 /* Now, we need to create a shortname from the long name */
337 ext_start
= end
= &uname
[ulen
];
338 while (--ext_start
>= uname
) {
339 if (*ext_start
== 0x002E) { /* is `.' */
340 if (ext_start
== end
- 1) {
348 if (ext_start
== uname
- 1) {
351 } else if (ext_start
) {
353 * Names which start with a dot could be just
354 * an extension eg. "...test". In this case Win95
355 * uses the extension as the name and sets no extension.
357 name_start
= &uname
[0];
358 while (name_start
< ext_start
) {
359 if (!vfat_skip_char(*name_start
))
363 if (name_start
!= ext_start
) {
364 sz
= ext_start
- uname
;
373 numtail2_baselen
= 2;
374 for (baselen
= i
= 0, p
= base
, ip
= uname
; i
< sz
; i
++, ip
++) {
375 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
380 if (baselen
< 2 && (baselen
+ chl
) > 2)
381 numtail2_baselen
= baselen
;
382 if (baselen
< 6 && (baselen
+ chl
) > 6)
383 numtail_baselen
= baselen
;
384 for (chi
= 0; chi
< chl
; chi
++) {
391 if ((chi
< chl
- 1) || (ip
+ 1) - uname
< sz
)
402 for (p
= ext
, ip
= ext_start
; extlen
< 3 && ip
< end
; ip
++) {
403 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
408 if ((extlen
+ chl
) > 3) {
412 for (chi
= 0; chi
< chl
; chi
++) {
424 base
[baselen
] = '\0';
426 /* Yes, it can happen. ".\xe5" would do it. */
427 if (base
[0] == DELETED_FLAG
)
430 /* OK, at this point we know that base is not longer than 8 symbols,
431 * ext is not longer than 3, base is nonempty, both don't contain
432 * any bad symbols (lowercase transformed to uppercase).
435 memset(name_res
, ' ', MSDOS_NAME
);
436 memcpy(name_res
, base
, baselen
);
437 memcpy(name_res
+ 8, ext
, extlen
);
439 if (is_shortname
&& base_info
.valid
&& ext_info
.valid
) {
440 if (vfat_find_form(dir
, name_res
) == 0)
443 if (opts
->shortname
& VFAT_SFN_CREATE_WIN95
) {
444 return (base_info
.upper
&& ext_info
.upper
);
445 } else if (opts
->shortname
& VFAT_SFN_CREATE_WINNT
) {
446 if ((base_info
.upper
|| base_info
.lower
) &&
447 (ext_info
.upper
|| ext_info
.lower
)) {
448 if (!base_info
.upper
&& base_info
.lower
)
449 *lcase
|= CASE_LOWER_BASE
;
450 if (!ext_info
.upper
&& ext_info
.lower
)
451 *lcase
|= CASE_LOWER_EXT
;
460 if (opts
->numtail
== 0)
461 if (vfat_find_form(dir
, name_res
) < 0)
465 * Try to find a unique extension. This used to
466 * iterate through all possibilities sequentially,
467 * but that gave extremely bad performance. Windows
468 * only tries a few cases before using random
469 * values for part of the base.
473 baselen
= numtail_baselen
;
476 name_res
[baselen
] = '~';
477 for (i
= 1; i
< 10; i
++) {
478 name_res
[baselen
+ 1] = i
+ '0';
479 if (vfat_find_form(dir
, name_res
) < 0)
484 sz
= (jiffies
>> 16) & 0x7;
486 baselen
= numtail2_baselen
;
489 name_res
[baselen
+ 4] = '~';
490 name_res
[baselen
+ 5] = '1' + sz
;
492 snprintf(buf
, sizeof(buf
), "%04X", i
& 0xffff);
493 memcpy(&name_res
[baselen
], buf
, 4);
494 if (vfat_find_form(dir
, name_res
) < 0)
501 /* Translate a string, including coded sequences into Unicode */
503 xlate_to_uni(const unsigned char *name
, int len
, unsigned char *outname
,
504 int *longlen
, int *outlen
, int escape
, int utf8
,
505 struct nls_table
*nls
)
507 const unsigned char *ip
;
515 *outlen
= utf8s_to_utf16s(name
, len
, UTF16_HOST_ENDIAN
,
516 (wchar_t *) outname
, FAT_LFN_LEN
+ 2);
519 else if (*outlen
> FAT_LFN_LEN
)
520 return -ENAMETOOLONG
;
522 op
= &outname
[*outlen
* sizeof(wchar_t)];
524 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
525 i
< len
&& *outlen
< FAT_LFN_LEN
;
527 if (escape
&& (*ip
== ':')) {
531 for (k
= 1; k
< 5; k
++) {
534 if (nc
>= '0' && nc
<= '9') {
538 if (nc
>= 'a' && nc
<= 'f') {
539 ec
|= nc
- ('a' - 10);
542 if (nc
>= 'A' && nc
<= 'F') {
543 ec
|= nc
- ('A' - 10);
553 charlen
= nls
->char2uni(ip
, len
- i
,
563 return -ENAMETOOLONG
;
572 fill
= 13 - (*outlen
% 13);
573 for (i
= 0; i
< fill
; i
++) {
584 static int vfat_build_slots(struct inode
*dir
, const unsigned char *name
,
585 int len
, int is_dir
, int cluster
,
587 struct msdos_dir_slot
*slots
, int *nr_slots
)
589 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
590 struct fat_mount_options
*opts
= &sbi
->options
;
591 struct msdos_dir_slot
*ps
;
592 struct msdos_dir_entry
*de
;
593 unsigned char cksum
, lcase
;
594 unsigned char msdos_name
[MSDOS_NAME
];
598 int err
, ulen
, usize
, i
;
607 err
= xlate_to_uni(name
, len
, (unsigned char *)uname
, &ulen
, &usize
,
608 opts
->unicode_xlate
, opts
->utf8
, sbi
->nls_io
);
612 err
= vfat_is_used_badchars(uname
, ulen
);
616 err
= vfat_create_shortname(dir
, sbi
->nls_disk
, uname
, ulen
,
621 de
= (struct msdos_dir_entry
*)slots
;
626 /* build the entry of long file name */
627 cksum
= fat_checksum(msdos_name
);
629 *nr_slots
= usize
/ 13;
630 for (ps
= slots
, i
= *nr_slots
; i
> 0; i
--, ps
++) {
634 ps
->alias_checksum
= cksum
;
636 offset
= (i
- 1) * 13;
637 fatwchar_to16(ps
->name0_4
, uname
+ offset
, 5);
638 fatwchar_to16(ps
->name5_10
, uname
+ offset
+ 5, 6);
639 fatwchar_to16(ps
->name11_12
, uname
+ offset
+ 11, 2);
642 de
= (struct msdos_dir_entry
*)ps
;
645 /* build the entry of 8.3 alias name */
647 memcpy(de
->name
, msdos_name
, MSDOS_NAME
);
648 de
->attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
650 fat_time_unix2fat(sbi
, ts
, &time
, &date
, &time_cs
);
651 de
->time
= de
->ctime
= time
;
652 de
->date
= de
->cdate
= de
->adate
= date
;
653 de
->ctime_cs
= time_cs
;
654 de
->start
= cpu_to_le16(cluster
);
655 de
->starthi
= cpu_to_le16(cluster
>> 16);
662 static int vfat_add_entry(struct inode
*dir
, struct qstr
*qname
, int is_dir
,
663 int cluster
, struct timespec
*ts
,
664 struct fat_slot_info
*sinfo
)
666 struct msdos_dir_slot
*slots
;
670 len
= vfat_striptail_len(qname
);
674 slots
= kmalloc(sizeof(*slots
) * MSDOS_SLOTS
, GFP_NOFS
);
678 err
= vfat_build_slots(dir
, qname
->name
, len
, is_dir
, cluster
, ts
,
683 err
= fat_add_entries(dir
, slots
, nr_slots
, sinfo
);
687 /* update timestamp */
688 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= *ts
;
690 (void)fat_sync_inode(dir
);
692 mark_inode_dirty(dir
);
698 static int vfat_find(struct inode
*dir
, struct qstr
*qname
,
699 struct fat_slot_info
*sinfo
)
701 unsigned int len
= vfat_striptail_len(qname
);
704 return fat_search_long(dir
, qname
->name
, len
, sinfo
);
708 * (nfsd's) anonymous disconnected dentry?
709 * NOTE: !IS_ROOT() is not anonymous (I.e. d_splice_alias() did the job).
711 static int vfat_d_anon_disconn(struct dentry
*dentry
)
713 return IS_ROOT(dentry
) && (dentry
->d_flags
& DCACHE_DISCONNECTED
);
716 static struct dentry
*vfat_lookup(struct inode
*dir
, struct dentry
*dentry
,
717 struct nameidata
*nd
)
719 struct super_block
*sb
= dir
->i_sb
;
720 struct fat_slot_info sinfo
;
722 struct dentry
*alias
;
727 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
729 if (err
== -ENOENT
) {
736 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
739 err
= PTR_ERR(inode
);
743 alias
= d_find_alias(inode
);
744 if (alias
&& !vfat_d_anon_disconn(alias
)) {
746 * This inode has non anonymous-DCACHE_DISCONNECTED
747 * dentry. This means, the user did ->lookup() by an
748 * another name (longname vs 8.3 alias of it) in past.
750 * Switch to new one for reason of locality if possible.
752 BUG_ON(d_unhashed(alias
));
753 if (!S_ISDIR(inode
->i_mode
))
754 d_move(alias
, dentry
);
763 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
764 dentry
= d_splice_alias(inode
, dentry
);
766 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
774 static int vfat_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
775 struct nameidata
*nd
)
777 struct super_block
*sb
= dir
->i_sb
;
779 struct fat_slot_info sinfo
;
785 ts
= CURRENT_TIME_SEC
;
786 err
= vfat_add_entry(dir
, &dentry
->d_name
, 0, 0, &ts
, &sinfo
);
791 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
794 err
= PTR_ERR(inode
);
798 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
799 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
801 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
802 d_instantiate(dentry
, inode
);
808 static int vfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
810 struct inode
*inode
= dentry
->d_inode
;
811 struct super_block
*sb
= dir
->i_sb
;
812 struct fat_slot_info sinfo
;
817 err
= fat_dir_empty(inode
);
820 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
824 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
830 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
838 static int vfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
840 struct inode
*inode
= dentry
->d_inode
;
841 struct super_block
*sb
= dir
->i_sb
;
842 struct fat_slot_info sinfo
;
847 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
851 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
855 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
863 static int vfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
865 struct super_block
*sb
= dir
->i_sb
;
867 struct fat_slot_info sinfo
;
873 ts
= CURRENT_TIME_SEC
;
874 cluster
= fat_alloc_new_dir(dir
, &ts
);
879 err
= vfat_add_entry(dir
, &dentry
->d_name
, 1, cluster
, &ts
, &sinfo
);
885 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
888 err
= PTR_ERR(inode
);
889 /* the directory was completed, just return a error */
894 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
895 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
897 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
898 d_instantiate(dentry
, inode
);
904 fat_free_clusters(dir
, cluster
);
910 static int vfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
911 struct inode
*new_dir
, struct dentry
*new_dentry
)
913 struct buffer_head
*dotdot_bh
;
914 struct msdos_dir_entry
*dotdot_de
;
915 struct inode
*old_inode
, *new_inode
;
916 struct fat_slot_info old_sinfo
, sinfo
;
918 loff_t dotdot_i_pos
, new_i_pos
;
919 int err
, is_dir
, update_dotdot
, corrupt
= 0;
920 struct super_block
*sb
= old_dir
->i_sb
;
922 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
923 old_inode
= old_dentry
->d_inode
;
924 new_inode
= new_dentry
->d_inode
;
926 err
= vfat_find(old_dir
, &old_dentry
->d_name
, &old_sinfo
);
930 is_dir
= S_ISDIR(old_inode
->i_mode
);
931 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
933 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
934 &dotdot_i_pos
) < 0) {
940 ts
= CURRENT_TIME_SEC
;
943 err
= fat_dir_empty(new_inode
);
947 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
948 fat_detach(new_inode
);
950 err
= vfat_add_entry(new_dir
, &new_dentry
->d_name
, is_dir
, 0,
954 new_i_pos
= sinfo
.i_pos
;
956 new_dir
->i_version
++;
958 fat_detach(old_inode
);
959 fat_attach(old_inode
, new_i_pos
);
960 if (IS_DIRSYNC(new_dir
)) {
961 err
= fat_sync_inode(old_inode
);
965 mark_inode_dirty(old_inode
);
968 int start
= MSDOS_I(new_dir
)->i_logstart
;
969 dotdot_de
->start
= cpu_to_le16(start
);
970 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
971 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
972 if (IS_DIRSYNC(new_dir
)) {
973 err
= sync_dirty_buffer(dotdot_bh
);
982 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
986 old_dir
->i_version
++;
987 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
988 if (IS_DIRSYNC(old_dir
))
989 (void)fat_sync_inode(old_dir
);
991 mark_inode_dirty(old_dir
);
994 drop_nlink(new_inode
);
996 drop_nlink(new_inode
);
997 new_inode
->i_ctime
= ts
;
1002 brelse(old_sinfo
.bh
);
1008 /* data cluster is shared, serious corruption */
1011 if (update_dotdot
) {
1012 int start
= MSDOS_I(old_dir
)->i_logstart
;
1013 dotdot_de
->start
= cpu_to_le16(start
);
1014 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
1015 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
1016 corrupt
|= sync_dirty_buffer(dotdot_bh
);
1019 fat_detach(old_inode
);
1020 fat_attach(old_inode
, old_sinfo
.i_pos
);
1022 fat_attach(new_inode
, new_i_pos
);
1024 corrupt
|= fat_sync_inode(new_inode
);
1027 * If new entry was not sharing the data cluster, it
1028 * shouldn't be serious corruption.
1030 int err2
= fat_remove_entries(new_dir
, &sinfo
);
1036 fat_fs_error(new_dir
->i_sb
,
1037 "%s: Filesystem corrupted (i_pos %lld)",
1038 __func__
, sinfo
.i_pos
);
1043 static const struct inode_operations vfat_dir_inode_operations
= {
1044 .create
= vfat_create
,
1045 .lookup
= vfat_lookup
,
1046 .unlink
= vfat_unlink
,
1047 .mkdir
= vfat_mkdir
,
1048 .rmdir
= vfat_rmdir
,
1049 .rename
= vfat_rename
,
1050 .setattr
= fat_setattr
,
1051 .getattr
= fat_getattr
,
1054 static void setup(struct super_block
*sb
)
1056 MSDOS_SB(sb
)->dir_ops
= &vfat_dir_inode_operations
;
1057 if (MSDOS_SB(sb
)->options
.name_check
!= 's')
1058 sb
->s_d_op
= &vfat_ci_dentry_ops
;
1060 sb
->s_d_op
= &vfat_dentry_ops
;
1063 static int vfat_fill_super(struct super_block
*sb
, void *data
, int silent
)
1065 return fat_fill_super(sb
, data
, silent
, 1, setup
);
1068 static struct dentry
*vfat_mount(struct file_system_type
*fs_type
,
1069 int flags
, const char *dev_name
,
1072 return mount_bdev(fs_type
, flags
, dev_name
, data
, vfat_fill_super
);
1075 static struct file_system_type vfat_fs_type
= {
1076 .owner
= THIS_MODULE
,
1078 .mount
= vfat_mount
,
1079 .kill_sb
= kill_block_super
,
1080 .fs_flags
= FS_REQUIRES_DEV
,
1083 static int __init
init_vfat_fs(void)
1085 return register_filesystem(&vfat_fs_type
);
1088 static void __exit
exit_vfat_fs(void)
1090 unregister_filesystem(&vfat_fs_type
);
1093 MODULE_LICENSE("GPL");
1094 MODULE_DESCRIPTION("VFAT filesystem support");
1095 MODULE_AUTHOR("Gordon Chaffee");
1097 module_init(init_vfat_fs
)
1098 module_exit(exit_vfat_fs
)