2 * linux/fs/msdos/namei.c
4 * Written 1992,1993 by Werner Almesberger
5 * Hidden files 1995 by Albert Cahalan <albert@ccs.neu.edu> <adc@coe.neu.edu>
6 * Rewritten for constant inumbers 1999 by Al Viro
9 #include <linux/module.h>
10 #include <linux/time.h>
11 #include <linux/buffer_head.h>
14 /* Characters that are undesirable in an MS-DOS file name */
15 static unsigned char bad_chars
[] = "*?<>|\"";
16 static unsigned char bad_if_strict
[] = "+=,; ";
18 /***** Formats an MS-DOS file name. Rejects invalid names. */
19 static int msdos_format_name(const unsigned char *name
, int len
,
20 unsigned char *res
, struct fat_mount_options
*opts
)
22 * name is the proposed name, len is its length, res is
23 * the resulting name, opts->name_check is either (r)elaxed,
24 * (n)ormal or (s)trict, opts->dotsOK allows dots at the
25 * beginning of name (for hidden files)
32 if (name
[0] == '.') { /* dotfile because . and .. already done */
34 /* Get rid of dot - test for it elsewhere */
41 * disallow names that _really_ start with a dot
45 for (walk
= res
; len
&& walk
- res
< 8; walk
++) {
48 if (opts
->name_check
!= 'r' && strchr(bad_chars
, c
))
50 if (opts
->name_check
== 's' && strchr(bad_if_strict
, c
))
52 if (c
>= 'A' && c
<= 'Z' && opts
->name_check
== 's')
54 if (c
< ' ' || c
== ':' || c
== '\\')
57 * 0xE5 is legal as a first character, but we must substitute
58 * 0x05 because 0xE5 marks deleted files. Yes, DOS really
60 * It seems that Microsoft hacked DOS to support non-US
61 * characters after the 0xE5 character was already in use to
64 if ((res
== walk
) && (c
== 0xE5))
69 *walk
= (!opts
->nocase
&& c
>= 'a' && c
<= 'z') ? c
- 32 : c
;
73 if (opts
->name_check
== 's' && len
&& c
!= '.') {
79 while (c
!= '.' && len
--)
82 while (walk
- res
< 8)
84 while (len
> 0 && walk
- res
< MSDOS_NAME
) {
87 if (opts
->name_check
!= 'r' && strchr(bad_chars
, c
))
89 if (opts
->name_check
== 's' &&
90 strchr(bad_if_strict
, c
))
92 if (c
< ' ' || c
== ':' || c
== '\\')
95 if (opts
->name_check
== 's')
99 if (c
>= 'A' && c
<= 'Z' && opts
->name_check
== 's')
102 if (!opts
->nocase
&& c
>= 'a' && c
<= 'z')
109 if (opts
->name_check
== 's' && len
)
112 while (walk
- res
< MSDOS_NAME
)
118 /***** Locates a directory entry. Uses unformatted name. */
119 static int msdos_find(struct inode
*dir
, const unsigned char *name
, int len
,
120 struct fat_slot_info
*sinfo
)
122 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
123 unsigned char msdos_name
[MSDOS_NAME
];
126 err
= msdos_format_name(name
, len
, msdos_name
, &sbi
->options
);
130 err
= fat_scan(dir
, msdos_name
, sinfo
);
131 if (!err
&& sbi
->options
.dotsOK
) {
132 if (name
[0] == '.') {
133 if (!(sinfo
->de
->attr
& ATTR_HIDDEN
))
136 if (sinfo
->de
->attr
& ATTR_HIDDEN
)
146 * Compute the hash for the msdos name corresponding to the dentry.
147 * Note: if the name is invalid, we leave the hash code unchanged so
148 * that the existing dentry can be used. The msdos fs routines will
149 * return ENOENT or EINVAL as appropriate.
151 static int msdos_hash(const struct dentry
*dentry
, const struct inode
*inode
,
154 struct fat_mount_options
*options
= &MSDOS_SB(dentry
->d_sb
)->options
;
155 unsigned char msdos_name
[MSDOS_NAME
];
158 error
= msdos_format_name(qstr
->name
, qstr
->len
, msdos_name
, options
);
160 qstr
->hash
= full_name_hash(msdos_name
, MSDOS_NAME
);
165 * Compare two msdos names. If either of the names are invalid,
166 * we fall back to doing the standard name comparison.
168 static int msdos_cmp(const struct dentry
*parent
, const struct inode
*pinode
,
169 const struct dentry
*dentry
, const struct inode
*inode
,
170 unsigned int len
, const char *str
, const struct qstr
*name
)
172 struct fat_mount_options
*options
= &MSDOS_SB(parent
->d_sb
)->options
;
173 unsigned char a_msdos_name
[MSDOS_NAME
], b_msdos_name
[MSDOS_NAME
];
176 error
= msdos_format_name(name
->name
, name
->len
, a_msdos_name
, options
);
179 error
= msdos_format_name(str
, len
, b_msdos_name
, options
);
182 error
= memcmp(a_msdos_name
, b_msdos_name
, MSDOS_NAME
);
188 if (name
->len
== len
)
189 error
= memcmp(name
->name
, str
, len
);
193 static const struct dentry_operations msdos_dentry_operations
= {
194 .d_hash
= msdos_hash
,
195 .d_compare
= msdos_cmp
,
199 * AV. Wrappers for FAT sb operations. Is it wise?
202 /***** Get inode using directory and name */
203 static struct dentry
*msdos_lookup(struct inode
*dir
, struct dentry
*dentry
,
206 struct super_block
*sb
= dir
->i_sb
;
207 struct fat_slot_info sinfo
;
212 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
218 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
222 inode
= ERR_PTR(err
);
225 return d_splice_alias(inode
, dentry
);
228 /***** Creates a directory entry (name is already formatted). */
229 static int msdos_add_entry(struct inode
*dir
, const unsigned char *name
,
230 int is_dir
, int is_hid
, int cluster
,
231 struct timespec
*ts
, struct fat_slot_info
*sinfo
)
233 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
234 struct msdos_dir_entry de
;
238 memcpy(de
.name
, name
, MSDOS_NAME
);
239 de
.attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
241 de
.attr
|= ATTR_HIDDEN
;
243 fat_time_unix2fat(sbi
, ts
, &time
, &date
, NULL
);
244 de
.cdate
= de
.adate
= 0;
249 fat_set_start(&de
, cluster
);
252 err
= fat_add_entries(dir
, &de
, 1, sinfo
);
256 dir
->i_ctime
= dir
->i_mtime
= *ts
;
258 (void)fat_sync_inode(dir
);
260 mark_inode_dirty(dir
);
265 /***** Create a file */
266 static int msdos_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
269 struct super_block
*sb
= dir
->i_sb
;
270 struct inode
*inode
= NULL
;
271 struct fat_slot_info sinfo
;
273 unsigned char msdos_name
[MSDOS_NAME
];
278 err
= msdos_format_name(dentry
->d_name
.name
, dentry
->d_name
.len
,
279 msdos_name
, &MSDOS_SB(sb
)->options
);
282 is_hid
= (dentry
->d_name
.name
[0] == '.') && (msdos_name
[0] != '.');
283 /* Have to do it due to foo vs. .foo conflicts */
284 if (!fat_scan(dir
, msdos_name
, &sinfo
)) {
290 ts
= CURRENT_TIME_SEC
;
291 err
= msdos_add_entry(dir
, msdos_name
, 0, is_hid
, 0, &ts
, &sinfo
);
294 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
297 err
= PTR_ERR(inode
);
300 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
301 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
303 d_instantiate(dentry
, inode
);
307 err
= fat_flush_inodes(sb
, dir
, inode
);
311 /***** Remove a directory */
312 static int msdos_rmdir(struct inode
*dir
, struct dentry
*dentry
)
314 struct super_block
*sb
= dir
->i_sb
;
315 struct inode
*inode
= dentry
->d_inode
;
316 struct fat_slot_info sinfo
;
321 * Check whether the directory is not in use, then check
322 * whether it is empty.
324 err
= fat_dir_empty(inode
);
327 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
331 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
337 inode
->i_ctime
= CURRENT_TIME_SEC
;
342 err
= fat_flush_inodes(sb
, dir
, inode
);
347 /***** Make a directory */
348 static int msdos_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
350 struct super_block
*sb
= dir
->i_sb
;
351 struct fat_slot_info sinfo
;
353 unsigned char msdos_name
[MSDOS_NAME
];
355 int err
, is_hid
, cluster
;
359 err
= msdos_format_name(dentry
->d_name
.name
, dentry
->d_name
.len
,
360 msdos_name
, &MSDOS_SB(sb
)->options
);
363 is_hid
= (dentry
->d_name
.name
[0] == '.') && (msdos_name
[0] != '.');
364 /* foo vs .foo situation */
365 if (!fat_scan(dir
, msdos_name
, &sinfo
)) {
371 ts
= CURRENT_TIME_SEC
;
372 cluster
= fat_alloc_new_dir(dir
, &ts
);
377 err
= msdos_add_entry(dir
, msdos_name
, 1, is_hid
, cluster
, &ts
, &sinfo
);
382 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
385 err
= PTR_ERR(inode
);
386 /* the directory was completed, just return a error */
390 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
391 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
393 d_instantiate(dentry
, inode
);
396 fat_flush_inodes(sb
, dir
, inode
);
400 fat_free_clusters(dir
, cluster
);
406 /***** Unlink a file */
407 static int msdos_unlink(struct inode
*dir
, struct dentry
*dentry
)
409 struct inode
*inode
= dentry
->d_inode
;
410 struct super_block
*sb
= inode
->i_sb
;
411 struct fat_slot_info sinfo
;
415 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
419 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
423 inode
->i_ctime
= CURRENT_TIME_SEC
;
428 err
= fat_flush_inodes(sb
, dir
, inode
);
433 static int do_msdos_rename(struct inode
*old_dir
, unsigned char *old_name
,
434 struct dentry
*old_dentry
,
435 struct inode
*new_dir
, unsigned char *new_name
,
436 struct dentry
*new_dentry
, int is_hid
)
438 struct buffer_head
*dotdot_bh
;
439 struct msdos_dir_entry
*dotdot_de
;
440 struct inode
*old_inode
, *new_inode
;
441 struct fat_slot_info old_sinfo
, sinfo
;
443 loff_t dotdot_i_pos
, new_i_pos
;
444 int err
, old_attrs
, is_dir
, update_dotdot
, corrupt
= 0;
446 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
447 old_inode
= old_dentry
->d_inode
;
448 new_inode
= new_dentry
->d_inode
;
450 err
= fat_scan(old_dir
, old_name
, &old_sinfo
);
456 is_dir
= S_ISDIR(old_inode
->i_mode
);
457 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
459 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
460 &dotdot_i_pos
) < 0) {
466 old_attrs
= MSDOS_I(old_inode
)->i_attrs
;
467 err
= fat_scan(new_dir
, new_name
, &sinfo
);
470 /* "foo" -> ".foo" case. just change the ATTR_HIDDEN */
471 if (sinfo
.de
!= old_sinfo
.de
) {
476 MSDOS_I(old_inode
)->i_attrs
|= ATTR_HIDDEN
;
478 MSDOS_I(old_inode
)->i_attrs
&= ~ATTR_HIDDEN
;
479 if (IS_DIRSYNC(old_dir
)) {
480 err
= fat_sync_inode(old_inode
);
482 MSDOS_I(old_inode
)->i_attrs
= old_attrs
;
486 mark_inode_dirty(old_inode
);
488 old_dir
->i_version
++;
489 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME_SEC
;
490 if (IS_DIRSYNC(old_dir
))
491 (void)fat_sync_inode(old_dir
);
493 mark_inode_dirty(old_dir
);
498 ts
= CURRENT_TIME_SEC
;
503 err
= fat_dir_empty(new_inode
);
507 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
508 fat_detach(new_inode
);
510 err
= msdos_add_entry(new_dir
, new_name
, is_dir
, is_hid
, 0,
514 new_i_pos
= sinfo
.i_pos
;
516 new_dir
->i_version
++;
518 fat_detach(old_inode
);
519 fat_attach(old_inode
, new_i_pos
);
521 MSDOS_I(old_inode
)->i_attrs
|= ATTR_HIDDEN
;
523 MSDOS_I(old_inode
)->i_attrs
&= ~ATTR_HIDDEN
;
524 if (IS_DIRSYNC(new_dir
)) {
525 err
= fat_sync_inode(old_inode
);
529 mark_inode_dirty(old_inode
);
532 fat_set_start(dotdot_de
, MSDOS_I(new_dir
)->i_logstart
);
533 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
534 if (IS_DIRSYNC(new_dir
)) {
535 err
= sync_dirty_buffer(dotdot_bh
);
544 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
548 old_dir
->i_version
++;
549 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
550 if (IS_DIRSYNC(old_dir
))
551 (void)fat_sync_inode(old_dir
);
553 mark_inode_dirty(old_dir
);
556 drop_nlink(new_inode
);
558 drop_nlink(new_inode
);
559 new_inode
->i_ctime
= ts
;
564 brelse(old_sinfo
.bh
);
568 /* data cluster is shared, serious corruption */
572 fat_set_start(dotdot_de
, MSDOS_I(old_dir
)->i_logstart
);
573 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
574 corrupt
|= sync_dirty_buffer(dotdot_bh
);
577 fat_detach(old_inode
);
578 fat_attach(old_inode
, old_sinfo
.i_pos
);
579 MSDOS_I(old_inode
)->i_attrs
= old_attrs
;
581 fat_attach(new_inode
, new_i_pos
);
583 corrupt
|= fat_sync_inode(new_inode
);
586 * If new entry was not sharing the data cluster, it
587 * shouldn't be serious corruption.
589 int err2
= fat_remove_entries(new_dir
, &sinfo
);
595 fat_fs_error(new_dir
->i_sb
,
596 "%s: Filesystem corrupted (i_pos %lld)",
597 __func__
, sinfo
.i_pos
);
602 /***** Rename, a wrapper for rename_same_dir & rename_diff_dir */
603 static int msdos_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
604 struct inode
*new_dir
, struct dentry
*new_dentry
)
606 struct super_block
*sb
= old_dir
->i_sb
;
607 unsigned char old_msdos_name
[MSDOS_NAME
], new_msdos_name
[MSDOS_NAME
];
612 err
= msdos_format_name(old_dentry
->d_name
.name
,
613 old_dentry
->d_name
.len
, old_msdos_name
,
614 &MSDOS_SB(old_dir
->i_sb
)->options
);
617 err
= msdos_format_name(new_dentry
->d_name
.name
,
618 new_dentry
->d_name
.len
, new_msdos_name
,
619 &MSDOS_SB(new_dir
->i_sb
)->options
);
624 (new_dentry
->d_name
.name
[0] == '.') && (new_msdos_name
[0] != '.');
626 err
= do_msdos_rename(old_dir
, old_msdos_name
, old_dentry
,
627 new_dir
, new_msdos_name
, new_dentry
, is_hid
);
631 err
= fat_flush_inodes(sb
, old_dir
, new_dir
);
635 static const struct inode_operations msdos_dir_inode_operations
= {
636 .create
= msdos_create
,
637 .lookup
= msdos_lookup
,
638 .unlink
= msdos_unlink
,
639 .mkdir
= msdos_mkdir
,
640 .rmdir
= msdos_rmdir
,
641 .rename
= msdos_rename
,
642 .setattr
= fat_setattr
,
643 .getattr
= fat_getattr
,
646 static void setup(struct super_block
*sb
)
648 MSDOS_SB(sb
)->dir_ops
= &msdos_dir_inode_operations
;
649 sb
->s_d_op
= &msdos_dentry_operations
;
650 sb
->s_flags
|= MS_NOATIME
;
653 static int msdos_fill_super(struct super_block
*sb
, void *data
, int silent
)
655 return fat_fill_super(sb
, data
, silent
, 0, setup
);
658 static struct dentry
*msdos_mount(struct file_system_type
*fs_type
,
659 int flags
, const char *dev_name
,
662 return mount_bdev(fs_type
, flags
, dev_name
, data
, msdos_fill_super
);
665 static struct file_system_type msdos_fs_type
= {
666 .owner
= THIS_MODULE
,
668 .mount
= msdos_mount
,
669 .kill_sb
= kill_block_super
,
670 .fs_flags
= FS_REQUIRES_DEV
,
673 static int __init
init_msdos_fs(void)
675 return register_filesystem(&msdos_fs_type
);
678 static void __exit
exit_msdos_fs(void)
680 unregister_filesystem(&msdos_fs_type
);
683 MODULE_LICENSE("GPL");
684 MODULE_AUTHOR("Werner Almesberger");
685 MODULE_DESCRIPTION("MS-DOS filesystem support");
687 module_init(init_msdos_fs
)
688 module_exit(exit_msdos_fs
)