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(struct dentry
*dentry
, struct qstr
*qstr
)
153 struct fat_mount_options
*options
= &MSDOS_SB(dentry
->d_sb
)->options
;
154 unsigned char msdos_name
[MSDOS_NAME
];
157 error
= msdos_format_name(qstr
->name
, qstr
->len
, msdos_name
, options
);
159 qstr
->hash
= full_name_hash(msdos_name
, MSDOS_NAME
);
164 * Compare two msdos names. If either of the names are invalid,
165 * we fall back to doing the standard name comparison.
167 static int msdos_cmp(const struct dentry
*parent
, const struct inode
*pinode
,
168 const struct dentry
*dentry
, const struct inode
*inode
,
169 unsigned int len
, const char *str
, const struct qstr
*name
)
171 struct fat_mount_options
*options
= &MSDOS_SB(parent
->d_sb
)->options
;
172 unsigned char a_msdos_name
[MSDOS_NAME
], b_msdos_name
[MSDOS_NAME
];
175 error
= msdos_format_name(name
->name
, name
->len
, a_msdos_name
, options
);
178 error
= msdos_format_name(str
, len
, b_msdos_name
, options
);
181 error
= memcmp(a_msdos_name
, b_msdos_name
, MSDOS_NAME
);
187 if (name
->len
== len
)
188 error
= memcmp(name
->name
, str
, len
);
192 static const struct dentry_operations msdos_dentry_operations
= {
193 .d_hash
= msdos_hash
,
194 .d_compare
= msdos_cmp
,
198 * AV. Wrappers for FAT sb operations. Is it wise?
201 /***** Get inode using directory and name */
202 static struct dentry
*msdos_lookup(struct inode
*dir
, struct dentry
*dentry
,
203 struct nameidata
*nd
)
205 struct super_block
*sb
= dir
->i_sb
;
206 struct fat_slot_info sinfo
;
212 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
214 if (err
== -ENOENT
) {
221 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
224 err
= PTR_ERR(inode
);
229 dentry
->d_op
= &msdos_dentry_operations
;
230 dentry
= d_splice_alias(inode
, dentry
);
232 dentry
->d_op
= &msdos_dentry_operations
;
240 /***** Creates a directory entry (name is already formatted). */
241 static int msdos_add_entry(struct inode
*dir
, const unsigned char *name
,
242 int is_dir
, int is_hid
, int cluster
,
243 struct timespec
*ts
, struct fat_slot_info
*sinfo
)
245 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
246 struct msdos_dir_entry de
;
250 memcpy(de
.name
, name
, MSDOS_NAME
);
251 de
.attr
= is_dir
? ATTR_DIR
: ATTR_ARCH
;
253 de
.attr
|= ATTR_HIDDEN
;
255 fat_time_unix2fat(sbi
, ts
, &time
, &date
, NULL
);
256 de
.cdate
= de
.adate
= 0;
261 de
.start
= cpu_to_le16(cluster
);
262 de
.starthi
= cpu_to_le16(cluster
>> 16);
265 err
= fat_add_entries(dir
, &de
, 1, sinfo
);
269 dir
->i_ctime
= dir
->i_mtime
= *ts
;
271 (void)fat_sync_inode(dir
);
273 mark_inode_dirty(dir
);
278 /***** Create a file */
279 static int msdos_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
280 struct nameidata
*nd
)
282 struct super_block
*sb
= dir
->i_sb
;
283 struct inode
*inode
= NULL
;
284 struct fat_slot_info sinfo
;
286 unsigned char msdos_name
[MSDOS_NAME
];
291 err
= msdos_format_name(dentry
->d_name
.name
, dentry
->d_name
.len
,
292 msdos_name
, &MSDOS_SB(sb
)->options
);
295 is_hid
= (dentry
->d_name
.name
[0] == '.') && (msdos_name
[0] != '.');
296 /* Have to do it due to foo vs. .foo conflicts */
297 if (!fat_scan(dir
, msdos_name
, &sinfo
)) {
303 ts
= CURRENT_TIME_SEC
;
304 err
= msdos_add_entry(dir
, msdos_name
, 0, is_hid
, 0, &ts
, &sinfo
);
307 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
310 err
= PTR_ERR(inode
);
313 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
314 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
316 d_instantiate(dentry
, inode
);
320 err
= fat_flush_inodes(sb
, dir
, inode
);
324 /***** Remove a directory */
325 static int msdos_rmdir(struct inode
*dir
, struct dentry
*dentry
)
327 struct super_block
*sb
= dir
->i_sb
;
328 struct inode
*inode
= dentry
->d_inode
;
329 struct fat_slot_info sinfo
;
334 * Check whether the directory is not in use, then check
335 * whether it is empty.
337 err
= fat_dir_empty(inode
);
340 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
344 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
350 inode
->i_ctime
= CURRENT_TIME_SEC
;
355 err
= fat_flush_inodes(sb
, dir
, inode
);
360 /***** Make a directory */
361 static int msdos_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
363 struct super_block
*sb
= dir
->i_sb
;
364 struct fat_slot_info sinfo
;
366 unsigned char msdos_name
[MSDOS_NAME
];
368 int err
, is_hid
, cluster
;
372 err
= msdos_format_name(dentry
->d_name
.name
, dentry
->d_name
.len
,
373 msdos_name
, &MSDOS_SB(sb
)->options
);
376 is_hid
= (dentry
->d_name
.name
[0] == '.') && (msdos_name
[0] != '.');
377 /* foo vs .foo situation */
378 if (!fat_scan(dir
, msdos_name
, &sinfo
)) {
384 ts
= CURRENT_TIME_SEC
;
385 cluster
= fat_alloc_new_dir(dir
, &ts
);
390 err
= msdos_add_entry(dir
, msdos_name
, 1, is_hid
, cluster
, &ts
, &sinfo
);
395 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
398 err
= PTR_ERR(inode
);
399 /* the directory was completed, just return a error */
403 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= ts
;
404 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
406 d_instantiate(dentry
, inode
);
409 fat_flush_inodes(sb
, dir
, inode
);
413 fat_free_clusters(dir
, cluster
);
419 /***** Unlink a file */
420 static int msdos_unlink(struct inode
*dir
, struct dentry
*dentry
)
422 struct inode
*inode
= dentry
->d_inode
;
423 struct super_block
*sb
= inode
->i_sb
;
424 struct fat_slot_info sinfo
;
428 err
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
432 err
= fat_remove_entries(dir
, &sinfo
); /* and releases bh */
436 inode
->i_ctime
= CURRENT_TIME_SEC
;
441 err
= fat_flush_inodes(sb
, dir
, inode
);
446 static int do_msdos_rename(struct inode
*old_dir
, unsigned char *old_name
,
447 struct dentry
*old_dentry
,
448 struct inode
*new_dir
, unsigned char *new_name
,
449 struct dentry
*new_dentry
, int is_hid
)
451 struct buffer_head
*dotdot_bh
;
452 struct msdos_dir_entry
*dotdot_de
;
453 struct inode
*old_inode
, *new_inode
;
454 struct fat_slot_info old_sinfo
, sinfo
;
456 loff_t dotdot_i_pos
, new_i_pos
;
457 int err
, old_attrs
, is_dir
, update_dotdot
, corrupt
= 0;
459 old_sinfo
.bh
= sinfo
.bh
= dotdot_bh
= NULL
;
460 old_inode
= old_dentry
->d_inode
;
461 new_inode
= new_dentry
->d_inode
;
463 err
= fat_scan(old_dir
, old_name
, &old_sinfo
);
469 is_dir
= S_ISDIR(old_inode
->i_mode
);
470 update_dotdot
= (is_dir
&& old_dir
!= new_dir
);
472 if (fat_get_dotdot_entry(old_inode
, &dotdot_bh
, &dotdot_de
,
473 &dotdot_i_pos
) < 0) {
479 old_attrs
= MSDOS_I(old_inode
)->i_attrs
;
480 err
= fat_scan(new_dir
, new_name
, &sinfo
);
483 /* "foo" -> ".foo" case. just change the ATTR_HIDDEN */
484 if (sinfo
.de
!= old_sinfo
.de
) {
489 MSDOS_I(old_inode
)->i_attrs
|= ATTR_HIDDEN
;
491 MSDOS_I(old_inode
)->i_attrs
&= ~ATTR_HIDDEN
;
492 if (IS_DIRSYNC(old_dir
)) {
493 err
= fat_sync_inode(old_inode
);
495 MSDOS_I(old_inode
)->i_attrs
= old_attrs
;
499 mark_inode_dirty(old_inode
);
501 old_dir
->i_version
++;
502 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME_SEC
;
503 if (IS_DIRSYNC(old_dir
))
504 (void)fat_sync_inode(old_dir
);
506 mark_inode_dirty(old_dir
);
511 ts
= CURRENT_TIME_SEC
;
516 err
= fat_dir_empty(new_inode
);
520 new_i_pos
= MSDOS_I(new_inode
)->i_pos
;
521 fat_detach(new_inode
);
523 err
= msdos_add_entry(new_dir
, new_name
, is_dir
, is_hid
, 0,
527 new_i_pos
= sinfo
.i_pos
;
529 new_dir
->i_version
++;
531 fat_detach(old_inode
);
532 fat_attach(old_inode
, new_i_pos
);
534 MSDOS_I(old_inode
)->i_attrs
|= ATTR_HIDDEN
;
536 MSDOS_I(old_inode
)->i_attrs
&= ~ATTR_HIDDEN
;
537 if (IS_DIRSYNC(new_dir
)) {
538 err
= fat_sync_inode(old_inode
);
542 mark_inode_dirty(old_inode
);
545 int start
= MSDOS_I(new_dir
)->i_logstart
;
546 dotdot_de
->start
= cpu_to_le16(start
);
547 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
548 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
549 if (IS_DIRSYNC(new_dir
)) {
550 err
= sync_dirty_buffer(dotdot_bh
);
559 err
= fat_remove_entries(old_dir
, &old_sinfo
); /* and releases bh */
563 old_dir
->i_version
++;
564 old_dir
->i_ctime
= old_dir
->i_mtime
= ts
;
565 if (IS_DIRSYNC(old_dir
))
566 (void)fat_sync_inode(old_dir
);
568 mark_inode_dirty(old_dir
);
571 drop_nlink(new_inode
);
573 drop_nlink(new_inode
);
574 new_inode
->i_ctime
= ts
;
579 brelse(old_sinfo
.bh
);
583 /* data cluster is shared, serious corruption */
587 int start
= MSDOS_I(old_dir
)->i_logstart
;
588 dotdot_de
->start
= cpu_to_le16(start
);
589 dotdot_de
->starthi
= cpu_to_le16(start
>> 16);
590 mark_buffer_dirty_inode(dotdot_bh
, old_inode
);
591 corrupt
|= sync_dirty_buffer(dotdot_bh
);
594 fat_detach(old_inode
);
595 fat_attach(old_inode
, old_sinfo
.i_pos
);
596 MSDOS_I(old_inode
)->i_attrs
= old_attrs
;
598 fat_attach(new_inode
, new_i_pos
);
600 corrupt
|= fat_sync_inode(new_inode
);
603 * If new entry was not sharing the data cluster, it
604 * shouldn't be serious corruption.
606 int err2
= fat_remove_entries(new_dir
, &sinfo
);
612 fat_fs_error(new_dir
->i_sb
,
613 "%s: Filesystem corrupted (i_pos %lld)",
614 __func__
, sinfo
.i_pos
);
619 /***** Rename, a wrapper for rename_same_dir & rename_diff_dir */
620 static int msdos_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
621 struct inode
*new_dir
, struct dentry
*new_dentry
)
623 struct super_block
*sb
= old_dir
->i_sb
;
624 unsigned char old_msdos_name
[MSDOS_NAME
], new_msdos_name
[MSDOS_NAME
];
629 err
= msdos_format_name(old_dentry
->d_name
.name
,
630 old_dentry
->d_name
.len
, old_msdos_name
,
631 &MSDOS_SB(old_dir
->i_sb
)->options
);
634 err
= msdos_format_name(new_dentry
->d_name
.name
,
635 new_dentry
->d_name
.len
, new_msdos_name
,
636 &MSDOS_SB(new_dir
->i_sb
)->options
);
641 (new_dentry
->d_name
.name
[0] == '.') && (new_msdos_name
[0] != '.');
643 err
= do_msdos_rename(old_dir
, old_msdos_name
, old_dentry
,
644 new_dir
, new_msdos_name
, new_dentry
, is_hid
);
648 err
= fat_flush_inodes(sb
, old_dir
, new_dir
);
652 static const struct inode_operations msdos_dir_inode_operations
= {
653 .create
= msdos_create
,
654 .lookup
= msdos_lookup
,
655 .unlink
= msdos_unlink
,
656 .mkdir
= msdos_mkdir
,
657 .rmdir
= msdos_rmdir
,
658 .rename
= msdos_rename
,
659 .setattr
= fat_setattr
,
660 .getattr
= fat_getattr
,
663 static int msdos_fill_super(struct super_block
*sb
, void *data
, int silent
)
668 res
= fat_fill_super(sb
, data
, silent
, &msdos_dir_inode_operations
, 0);
674 sb
->s_flags
|= MS_NOATIME
;
675 sb
->s_root
->d_op
= &msdos_dentry_operations
;
680 static struct dentry
*msdos_mount(struct file_system_type
*fs_type
,
681 int flags
, const char *dev_name
,
684 return mount_bdev(fs_type
, flags
, dev_name
, data
, msdos_fill_super
);
687 static struct file_system_type msdos_fs_type
= {
688 .owner
= THIS_MODULE
,
690 .mount
= msdos_mount
,
691 .kill_sb
= kill_block_super
,
692 .fs_flags
= FS_REQUIRES_DEV
,
695 static int __init
init_msdos_fs(void)
697 return register_filesystem(&msdos_fs_type
);
700 static void __exit
exit_msdos_fs(void)
702 unregister_filesystem(&msdos_fs_type
);
705 MODULE_LICENSE("GPL");
706 MODULE_AUTHOR("Werner Almesberger");
707 MODULE_DESCRIPTION("MS-DOS filesystem support");
709 module_init(init_msdos_fs
)
710 module_exit(exit_msdos_fs
)