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>
24 #include <linux/smp_lock.h> /* For lock_kernel() */
28 * If new entry was created in the parent, it could create the 8.3
29 * alias (the shortname of logname). So, the parent may have the
30 * negative-dentry which matches the created 8.3 alias.
32 * If it happened, the negative dentry isn't actually negative
33 * anymore. So, drop it.
35 static int vfat_revalidate_shortname(struct dentry
*dentry
)
38 spin_lock(&dentry
->d_lock
);
39 if (dentry
->d_time
!= dentry
->d_parent
->d_inode
->i_version
)
41 spin_unlock(&dentry
->d_lock
);
45 static int vfat_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
47 /* This is not negative dentry. Always valid. */
50 return vfat_revalidate_shortname(dentry
);
53 static int vfat_revalidate_ci(struct dentry
*dentry
, struct nameidata
*nd
)
56 * This is not negative dentry. Always valid.
58 * Note, rename() to existing directory entry will have ->d_inode,
59 * and will use existing name which isn't specified name by user.
61 * We may be able to drop this positive dentry here. But dropping
62 * positive dentry isn't good idea. So it's unsupported like
63 * rename("filename", "FILENAME") for now.
69 * This may be nfsd (or something), anyway, we can't see the
70 * intent of this. So, since this can be for creation, drop it.
76 * Drop the negative dentry, in order to make sure to use the
77 * case sensitive name which is specified by user if this is
80 if (!(nd
->flags
& (LOOKUP_CONTINUE
| LOOKUP_PARENT
))) {
81 if (nd
->flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
85 return vfat_revalidate_shortname(dentry
);
88 /* returns the length of a struct qstr, ignoring trailing dots */
89 static unsigned int vfat_striptail_len(struct qstr
*qstr
)
91 unsigned int len
= qstr
->len
;
93 while (len
&& qstr
->name
[len
- 1] == '.')
99 * Compute the hash for the vfat name corresponding to the dentry.
100 * Note: if the name is invalid, we leave the hash code unchanged so
101 * that the existing dentry can be used. The vfat fs routines will
102 * return ENOENT or EINVAL as appropriate.
104 static int vfat_hash(struct dentry
*dentry
, struct qstr
*qstr
)
106 qstr
->hash
= full_name_hash(qstr
->name
, vfat_striptail_len(qstr
));
111 * Compute the hash for the vfat name corresponding to the dentry.
112 * Note: if the name is invalid, we leave the hash code unchanged so
113 * that the existing dentry can be used. The vfat fs routines will
114 * return ENOENT or EINVAL as appropriate.
116 static int vfat_hashi(struct dentry
*dentry
, struct qstr
*qstr
)
118 struct nls_table
*t
= MSDOS_SB(dentry
->d_inode
->i_sb
)->nls_io
;
119 const unsigned char *name
;
124 len
= vfat_striptail_len(qstr
);
126 hash
= init_name_hash();
128 hash
= partial_name_hash(nls_tolower(t
, *name
++), hash
);
129 qstr
->hash
= end_name_hash(hash
);
135 * Case insensitive compare of two vfat names.
137 static int vfat_cmpi(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
139 struct nls_table
*t
= MSDOS_SB(dentry
->d_inode
->i_sb
)->nls_io
;
140 unsigned int alen
, blen
;
142 /* A filename cannot end in '.' or we treat it like it has none */
143 alen
= vfat_striptail_len(a
);
144 blen
= vfat_striptail_len(b
);
146 if (nls_strnicmp(t
, a
->name
, b
->name
, alen
) == 0)
153 * Case sensitive compare of two vfat names.
155 static int vfat_cmp(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
157 unsigned int alen
, blen
;
159 /* A filename cannot end in '.' or we treat it like it has none */
160 alen
= vfat_striptail_len(a
);
161 blen
= vfat_striptail_len(b
);
163 if (strncmp(a
->name
, b
->name
, alen
) == 0)
169 static const struct dentry_operations vfat_ci_dentry_ops
= {
170 .d_revalidate
= vfat_revalidate_ci
,
171 .d_hash
= vfat_hashi
,
172 .d_compare
= vfat_cmpi
,
175 static const struct dentry_operations vfat_dentry_ops
= {
176 .d_revalidate
= vfat_revalidate
,
178 .d_compare
= vfat_cmp
,
181 /* Characters that are undesirable in an MS-DOS file name */
183 static inline wchar_t vfat_bad_char(wchar_t w
)
186 || (w
== '*') || (w
== '?') || (w
== '<') || (w
== '>')
187 || (w
== '|') || (w
== '"') || (w
== ':') || (w
== '/')
191 static inline wchar_t vfat_replace_char(wchar_t w
)
193 return (w
== '[') || (w
== ']') || (w
== ';') || (w
== ',')
194 || (w
== '+') || (w
== '=');
197 static wchar_t vfat_skip_char(wchar_t w
)
199 return (w
== '.') || (w
== ' ');
202 static inline int vfat_is_used_badchars(const wchar_t *s
, int len
)
206 for (i
= 0; i
< len
; i
++)
207 if (vfat_bad_char(s
[i
]))
210 if (s
[i
- 1] == ' ') /* last character cannot be space */
216 static int vfat_find_form(struct inode
*dir
, unsigned char *name
)
218 struct fat_slot_info sinfo
;
219 int err
= fat_scan(dir
, name
, &sinfo
);
227 * 1) Valid characters for the 8.3 format alias are any combination of
228 * letters, uppercase alphabets, digits, any of the
229 * following special characters:
230 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
231 * In this case Longfilename is not stored in disk.
234 * File name and extension name is contain uppercase/lowercase
235 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
237 * 2) File name is 8.3 format, but it contain the uppercase and
238 * lowercase char, muliti bytes char, etc. In this case numtail is not
239 * added, but Longfilename is stored.
241 * 3) When the one except for the above, or the following special
242 * character are contained:
244 * numtail is added, and Longfilename must be stored in disk .
246 struct shortname_info
{
247 unsigned char lower
:1,
251 #define INIT_SHORTNAME_INFO(x) do { \
257 static inline int to_shortname_char(struct nls_table
*nls
,
258 unsigned char *buf
, int buf_size
,
259 wchar_t *src
, struct shortname_info
*info
)
263 if (vfat_skip_char(*src
)) {
267 if (vfat_replace_char(*src
)) {
273 len
= nls
->uni2char(*src
, buf
, buf_size
);
278 } else if (len
== 1) {
279 unsigned char prev
= buf
[0];
281 if (buf
[0] >= 0x7F) {
286 buf
[0] = nls_toupper(nls
, buf
[0]);
287 if (isalpha(buf
[0])) {
302 * Given a valid longname, create a unique shortname. Make sure the
303 * shortname does not exist
304 * Returns negative number on error, 0 for a normal
305 * return, and 1 for valid shortname
307 static int vfat_create_shortname(struct inode
*dir
, struct nls_table
*nls
,
308 wchar_t *uname
, int ulen
,
309 unsigned char *name_res
, unsigned char *lcase
)
311 struct fat_mount_options
*opts
= &MSDOS_SB(dir
->i_sb
)->options
;
312 wchar_t *ip
, *ext_start
, *end
, *name_start
;
313 unsigned char base
[9], ext
[4], buf
[5], *p
;
314 unsigned char charbuf
[NLS_MAX_CHARSET_SIZE
];
316 int sz
= 0, extlen
, baselen
, i
, numtail_baselen
, numtail2_baselen
;
318 struct shortname_info base_info
, ext_info
;
321 INIT_SHORTNAME_INFO(&base_info
);
322 INIT_SHORTNAME_INFO(&ext_info
);
324 /* Now, we need to create a shortname from the long name */
325 ext_start
= end
= &uname
[ulen
];
326 while (--ext_start
>= uname
) {
327 if (*ext_start
== 0x002E) { /* is `.' */
328 if (ext_start
== end
- 1) {
336 if (ext_start
== uname
- 1) {
339 } else if (ext_start
) {
341 * Names which start with a dot could be just
342 * an extension eg. "...test". In this case Win95
343 * uses the extension as the name and sets no extension.
345 name_start
= &uname
[0];
346 while (name_start
< ext_start
) {
347 if (!vfat_skip_char(*name_start
))
351 if (name_start
!= ext_start
) {
352 sz
= ext_start
- uname
;
361 numtail2_baselen
= 2;
362 for (baselen
= i
= 0, p
= base
, ip
= uname
; i
< sz
; i
++, ip
++) {
363 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
368 if (baselen
< 2 && (baselen
+ chl
) > 2)
369 numtail2_baselen
= baselen
;
370 if (baselen
< 6 && (baselen
+ chl
) > 6)
371 numtail_baselen
= baselen
;
372 for (chi
= 0; chi
< chl
; chi
++) {
379 if ((chi
< chl
- 1) || (ip
+ 1) - uname
< sz
)
390 for (p
= ext
, ip
= ext_start
; extlen
< 3 && ip
< end
; ip
++) {
391 chl
= to_shortname_char(nls
, charbuf
, sizeof(charbuf
),
396 if ((extlen
+ chl
) > 3) {
400 for (chi
= 0; chi
< chl
; chi
++) {
412 base
[baselen
] = '\0';
414 /* Yes, it can happen. ".\xe5" would do it. */
415 if (base
[0] == DELETED_FLAG
)
418 /* OK, at this point we know that base is not longer than 8 symbols,
419 * ext is not longer than 3, base is nonempty, both don't contain
420 * any bad symbols (lowercase transformed to uppercase).
423 memset(name_res
, ' ', MSDOS_NAME
);
424 memcpy(name_res
, base
, baselen
);
425 memcpy(name_res
+ 8, ext
, extlen
);
427 if (is_shortname
&& base_info
.valid
&& ext_info
.valid
) {
428 if (vfat_find_form(dir
, name_res
) == 0)
431 if (opts
->shortname
& VFAT_SFN_CREATE_WIN95
) {
432 return (base_info
.upper
&& ext_info
.upper
);
433 } else if (opts
->shortname
& VFAT_SFN_CREATE_WINNT
) {
434 if ((base_info
.upper
|| base_info
.lower
) &&
435 (ext_info
.upper
|| ext_info
.lower
)) {
436 if (!base_info
.upper
&& base_info
.lower
)
437 *lcase
|= CASE_LOWER_BASE
;
438 if (!ext_info
.upper
&& ext_info
.lower
)
439 *lcase
|= CASE_LOWER_EXT
;
448 if (opts
->numtail
== 0)
449 if (vfat_find_form(dir
, name_res
) < 0)
453 * Try to find a unique extension. This used to
454 * iterate through all possibilities sequentially,
455 * but that gave extremely bad performance. Windows
456 * only tries a few cases before using random
457 * values for part of the base.
461 baselen
= numtail_baselen
;
464 name_res
[baselen
] = '~';
465 for (i
= 1; i
< 10; i
++) {
466 name_res
[baselen
+ 1] = i
+ '0';
467 if (vfat_find_form(dir
, name_res
) < 0)
472 sz
= (jiffies
>> 16) & 0x7;
474 baselen
= numtail2_baselen
;
477 name_res
[baselen
+ 4] = '~';
478 name_res
[baselen
+ 5] = '1' + sz
;
480 snprintf(buf
, sizeof(buf
), "%04X", i
& 0xffff);
481 memcpy(&name_res
[baselen
], buf
, 4);
482 if (vfat_find_form(dir
, name_res
) < 0)
489 /* Translate a string, including coded sequences into Unicode */
491 xlate_to_uni(const unsigned char *name
, int len
, unsigned char *outname
,
492 int *longlen
, int *outlen
, int escape
, int utf8
,
493 struct nls_table
*nls
)
495 const unsigned char *ip
;
503 *outlen
= utf8s_to_utf16s(name
, len
, (wchar_t *)outname
);
506 else if (*outlen
> FAT_LFN_LEN
)
507 return -ENAMETOOLONG
;
509 op
= &outname
[*outlen
* sizeof(wchar_t)];
512 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
513 i
< len
&& *outlen
<= FAT_LFN_LEN
;
516 if (escape
&& (*ip
== ':')) {
520 for (k
= 1; k
< 5; k
++) {
523 if (nc
>= '0' && nc
<= '9') {
527 if (nc
>= 'a' && nc
<= 'f') {
528 ec
|= nc
- ('a' - 10);
531 if (nc
>= 'A' && nc
<= 'F') {
532 ec
|= nc
- ('A' - 10);
542 if ((charlen
= nls
->char2uni(ip
, len
- i
, (wchar_t *)op
)) < 0)
550 return -ENAMETOOLONG
;
552 for (i
= 0, ip
= name
, op
= outname
, *outlen
= 0;
553 i
< len
&& *outlen
<= FAT_LFN_LEN
;
560 return -ENAMETOOLONG
;
570 fill
= 13 - (*outlen
% 13);
571 for (i
= 0; i
< fill
; i
++) {
582 static int vfat_build_slots(struct inode
*dir
, const unsigned char *name
,
583 int len
, int is_dir
, int cluster
,
585 struct msdos_dir_slot
*slots
, int *nr_slots
)
587 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
588 struct fat_mount_options
*opts
= &sbi
->options
;
589 struct msdos_dir_slot
*ps
;
590 struct msdos_dir_entry
*de
;
591 unsigned char cksum
, lcase
;
592 unsigned char msdos_name
[MSDOS_NAME
];
596 int err
, ulen
, usize
, i
;
605 err
= xlate_to_uni(name
, len
, (unsigned char *)uname
, &ulen
, &usize
,
606 opts
->unicode_xlate
, opts
->utf8
, sbi
->nls_io
);
610 err
= vfat_is_used_badchars(uname
, ulen
);
614 err
= vfat_create_shortname(dir
, sbi
->nls_disk
, uname
, ulen
,
619 de
= (struct msdos_dir_entry
*)slots
;
624 /* build the entry of long file name */
625 cksum
= fat_checksum(msdos_name
);
627 *nr_slots
= usize
/ 13;
628 for (ps
= slots
, i
= *nr_slots
; i
> 0; i
--, ps
++) {
632 ps
->alias_checksum
= cksum
;
634 offset
= (i
- 1) * 13;
635 fatwchar_to16(ps
->name0_4
, uname
+ offset
, 5);
636 fatwchar_to16(ps
->name5_10
, uname
+ offset
+ 5, 6);
637 fatwchar_to16(ps
->name11_12
, uname
+ offset
+ 11, 2);
640 de
= (struct msdos_dir_entry
*)ps
;
643 /* build the entry of 8.3 alias name */
645 memcpy(de
->name
, msdos_name
, MSDOS_NAME
);
646 de
->attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
648 fat_time_unix2fat(sbi
, ts
, &time
, &date
, &time_cs
);
649 de
->time
= de
->ctime
= time
;
650 de
->date
= de
->cdate
= de
->adate
= date
;
651 de
->ctime_cs
= time_cs
;
652 de
->start
= cpu_to_le16(cluster
);
653 de
->starthi
= cpu_to_le16(cluster
>> 16);
660 static int vfat_add_entry(struct inode
*dir
, struct qstr
*qname
, int is_dir
,
661 int cluster
, struct timespec
*ts
,
662 struct fat_slot_info
*sinfo
)
664 struct msdos_dir_slot
*slots
;
668 len
= vfat_striptail_len(qname
);
672 slots
= kmalloc(sizeof(*slots
) * MSDOS_SLOTS
, GFP_NOFS
);
676 err
= vfat_build_slots(dir
, qname
->name
, len
, is_dir
, cluster
, ts
,
681 err
= fat_add_entries(dir
, slots
, nr_slots
, sinfo
);
685 /* update timestamp */
686 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= *ts
;
688 (void)fat_sync_inode(dir
);
690 mark_inode_dirty(dir
);
696 static int vfat_find(struct inode
*dir
, struct qstr
*qname
,
697 struct fat_slot_info
*sinfo
)
699 unsigned int len
= vfat_striptail_len(qname
);
702 return fat_search_long(dir
, qname
->name
, len
, sinfo
);
706 * (nfsd's) anonymous disconnected dentry?
707 * NOTE: !IS_ROOT() is not anonymous (I.e. d_splice_alias() did the job).
709 static int vfat_d_anon_disconn(struct dentry
*dentry
)
711 return IS_ROOT(dentry
) && (dentry
->d_flags
& DCACHE_DISCONNECTED
);
714 static struct dentry
*vfat_lookup(struct inode
*dir
, struct dentry
*dentry
,
715 struct nameidata
*nd
)
717 struct super_block
*sb
= dir
->i_sb
;
718 struct fat_slot_info sinfo
;
720 struct dentry
*alias
;
725 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
727 if (err
== -ENOENT
) {
734 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
737 err
= PTR_ERR(inode
);
741 alias
= d_find_alias(inode
);
742 if (alias
&& !vfat_d_anon_disconn(alias
)) {
744 * This inode has non anonymous-DCACHE_DISCONNECTED
745 * dentry. This means, the user did ->lookup() by an
746 * another name (longname vs 8.3 alias of it) in past.
748 * Switch to new one for reason of locality if possible.
750 BUG_ON(d_unhashed(alias
));
751 if (!S_ISDIR(inode
->i_mode
))
752 d_move(alias
, dentry
);
761 dentry
->d_op
= sb
->s_root
->d_op
;
762 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
763 dentry
= d_splice_alias(inode
, dentry
);
765 dentry
->d_op
= sb
->s_root
->d_op
;
766 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
775 static int vfat_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
776 struct nameidata
*nd
)
778 struct super_block
*sb
= dir
->i_sb
;
780 struct fat_slot_info sinfo
;
786 ts
= CURRENT_TIME_SEC
;
787 err
= vfat_add_entry(dir
, &dentry
->d_name
, 0, 0, &ts
, &sinfo
);
792 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
795 err
= PTR_ERR(inode
);
799 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
800 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
802 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
803 d_instantiate(dentry
, inode
);
809 static int vfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
811 struct inode
*inode
= dentry
->d_inode
;
812 struct super_block
*sb
= dir
->i_sb
;
813 struct fat_slot_info sinfo
;
818 err
= fat_dir_empty(inode
);
821 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
825 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
831 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
839 static int vfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
841 struct inode
*inode
= dentry
->d_inode
;
842 struct super_block
*sb
= dir
->i_sb
;
843 struct fat_slot_info sinfo
;
848 err
= vfat_find(dir
, &dentry
->d_name
, &sinfo
);
852 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
856 inode
->i_mtime
= inode
->i_atime
= CURRENT_TIME_SEC
;
864 static int vfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
866 struct super_block
*sb
= dir
->i_sb
;
868 struct fat_slot_info sinfo
;
874 ts
= CURRENT_TIME_SEC
;
875 cluster
= fat_alloc_new_dir(dir
, &ts
);
880 err
= vfat_add_entry(dir
, &dentry
->d_name
, 1, cluster
, &ts
, &sinfo
);
886 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
889 err
= PTR_ERR(inode
);
890 /* the directory was completed, just return a error */
895 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
896 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
898 dentry
->d_time
= dentry
->d_parent
->d_inode
->i_version
;
899 d_instantiate(dentry
, inode
);
905 fat_free_clusters(dir
, cluster
);
911 static int vfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
912 struct inode
*new_dir
, struct dentry
*new_dentry
)
914 struct buffer_head
*dotdot_bh
;
915 struct msdos_dir_entry
*dotdot_de
;
916 struct inode
*old_inode
, *new_inode
;
917 struct fat_slot_info old_sinfo
, sinfo
;
919 loff_t dotdot_i_pos
, new_i_pos
;
920 int err
, is_dir
, update_dotdot
, corrupt
= 0;
921 struct super_block
*sb
= old_dir
->i_sb
;
923 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
924 old_inode
= old_dentry
->d_inode
;
925 new_inode
= new_dentry
->d_inode
;
927 err
= vfat_find(old_dir
, &old_dentry
->d_name
, &old_sinfo
);
931 is_dir
= S_ISDIR(old_inode
->i_mode
);
932 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
934 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
935 &dotdot_i_pos
) < 0) {
941 ts
= CURRENT_TIME_SEC
;
944 err
= fat_dir_empty(new_inode
);
948 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
949 fat_detach(new_inode
);
951 err
= vfat_add_entry(new_dir
, &new_dentry
->d_name
, is_dir
, 0,
955 new_i_pos
= sinfo
.i_pos
;
957 new_dir
->i_version
++;
959 fat_detach(old_inode
);
960 fat_attach(old_inode
, new_i_pos
);
961 if (IS_DIRSYNC(new_dir
)) {
962 err
= fat_sync_inode(old_inode
);
966 mark_inode_dirty(old_inode
);
969 int start
= MSDOS_I(new_dir
)->i_logstart
;
970 dotdot_de
->start
= cpu_to_le16(start
);
971 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
972 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
973 if (IS_DIRSYNC(new_dir
)) {
974 err
= sync_dirty_buffer(dotdot_bh
);
983 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
987 old_dir
->i_version
++;
988 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
989 if (IS_DIRSYNC(old_dir
))
990 (void)fat_sync_inode(old_dir
);
992 mark_inode_dirty(old_dir
);
995 drop_nlink(new_inode
);
997 drop_nlink(new_inode
);
998 new_inode
->i_ctime
= ts
;
1003 brelse(old_sinfo
.bh
);
1009 /* data cluster is shared, serious corruption */
1012 if (update_dotdot
) {
1013 int start
= MSDOS_I(old_dir
)->i_logstart
;
1014 dotdot_de
->start
= cpu_to_le16(start
);
1015 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
1016 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
1017 corrupt
|= sync_dirty_buffer(dotdot_bh
);
1020 fat_detach(old_inode
);
1021 fat_attach(old_inode
, old_sinfo
.i_pos
);
1023 fat_attach(new_inode
, new_i_pos
);
1025 corrupt
|= fat_sync_inode(new_inode
);
1028 * If new entry was not sharing the data cluster, it
1029 * shouldn't be serious corruption.
1031 int err2
= fat_remove_entries(new_dir
, &sinfo
);
1037 fat_fs_error(new_dir
->i_sb
,
1038 "%s: Filesystem corrupted (i_pos %lld)",
1039 __func__
, sinfo
.i_pos
);
1044 static const struct inode_operations vfat_dir_inode_operations
= {
1045 .create
= vfat_create
,
1046 .lookup
= vfat_lookup
,
1047 .unlink
= vfat_unlink
,
1048 .mkdir
= vfat_mkdir
,
1049 .rmdir
= vfat_rmdir
,
1050 .rename
= vfat_rename
,
1051 .setattr
= fat_setattr
,
1052 .getattr
= fat_getattr
,
1055 static int vfat_fill_super(struct super_block
*sb
, void *data
, int silent
)
1060 res
= fat_fill_super(sb
, data
, silent
, &vfat_dir_inode_operations
, 1);
1066 if (MSDOS_SB(sb
)->options
.name_check
!= 's')
1067 sb
->s_root
->d_op
= &vfat_ci_dentry_ops
;
1069 sb
->s_root
->d_op
= &vfat_dentry_ops
;
1075 static int vfat_get_sb(struct file_system_type
*fs_type
,
1076 int flags
, const char *dev_name
,
1077 void *data
, struct vfsmount
*mnt
)
1079 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, vfat_fill_super
,
1083 static struct file_system_type vfat_fs_type
= {
1084 .owner
= THIS_MODULE
,
1086 .get_sb
= vfat_get_sb
,
1087 .kill_sb
= kill_block_super
,
1088 .fs_flags
= FS_REQUIRES_DEV
,
1091 static int __init
init_vfat_fs(void)
1093 return register_filesystem(&vfat_fs_type
);
1096 static void __exit
exit_vfat_fs(void)
1098 unregister_filesystem(&vfat_fs_type
);
1101 MODULE_LICENSE("GPL");
1102 MODULE_DESCRIPTION("VFAT filesystem support");
1103 MODULE_AUTHOR("Gordon Chaffee");
1105 module_init(init_vfat_fs
)
1106 module_exit(exit_vfat_fs
)