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>
12 #include <linux/msdos_fs.h>
13 #include <linux/smp_lock.h>
15 /* Characters that are undesirable in an MS-DOS file name */
16 static unsigned char bad_chars
[] = "*?<>|\"";
17 static unsigned char bad_if_strict_pc
[] = "+=,; ";
18 /* GEMDOS is less restrictive */
19 static unsigned char bad_if_strict_atari
[] = " ";
21 #define bad_if_strict(opts) \
22 ((opts)->atari ? bad_if_strict_atari : bad_if_strict_pc)
24 /***** Formats an MS-DOS file name. Rejects invalid names. */
25 static int msdos_format_name(const unsigned char *name
, int len
,
26 unsigned char *res
, struct fat_mount_options
*opts
)
28 * name is the proposed name, len is its length, res is
29 * the resulting name, opts->name_check is either (r)elaxed,
30 * (n)ormal or (s)trict, opts->dotsOK allows dots at the
31 * beginning of name (for hidden files)
38 if (name
[0] == '.') { /* dotfile because . and .. already done */
40 /* Get rid of dot - test for it elsewhere */
43 } else if (!opts
->atari
)
47 * disallow names that _really_ start with a dot for MS-DOS,
48 * GEMDOS does not care
52 for (walk
= res
; len
&& walk
- res
< 8; walk
++) {
55 if (opts
->name_check
!= 'r' && strchr(bad_chars
, c
))
57 if (opts
->name_check
== 's' && strchr(bad_if_strict(opts
), c
))
59 if (c
>= 'A' && c
<= 'Z' && opts
->name_check
== 's')
61 if (c
< ' ' || c
== ':' || c
== '\\')
64 * 0xE5 is legal as a first character, but we must substitute
65 * 0x05 because 0xE5 marks deleted files. Yes, DOS really
67 * It seems that Microsoft hacked DOS to support non-US
68 * characters after the 0xE5 character was already in use to
71 if ((res
== walk
) && (c
== 0xE5))
76 *walk
= (!opts
->nocase
&& c
>= 'a' && c
<= 'z') ? c
- 32 : c
;
80 if (opts
->name_check
== 's' && len
&& c
!= '.') {
86 while (c
!= '.' && len
--)
89 while (walk
- res
< 8)
91 while (len
> 0 && walk
- res
< MSDOS_NAME
) {
94 if (opts
->name_check
!= 'r' && strchr(bad_chars
, c
))
96 if (opts
->name_check
== 's' &&
97 strchr(bad_if_strict(opts
), c
))
99 if (c
< ' ' || c
== ':' || c
== '\\')
102 if (opts
->name_check
== 's')
106 if (c
>= 'A' && c
<= 'Z' && opts
->name_check
== 's')
109 if (!opts
->nocase
&& c
>= 'a' && c
<= 'z')
116 if (opts
->name_check
== 's' && len
)
119 while (walk
- res
< MSDOS_NAME
)
125 /***** Locates a directory entry. Uses unformatted name. */
126 static int msdos_find(struct inode
*dir
, const unsigned char *name
, int len
,
127 struct fat_slot_info
*sinfo
)
129 struct msdos_sb_info
*sbi
= MSDOS_SB(dir
->i_sb
);
130 unsigned char msdos_name
[MSDOS_NAME
];
133 err
= msdos_format_name(name
, len
, msdos_name
, &sbi
->options
);
137 err
= fat_scan(dir
, msdos_name
, sinfo
);
138 if (!err
&& sbi
->options
.dotsOK
) {
139 if (name
[0] == '.') {
140 if (!(sinfo
->de
->attr
& ATTR_HIDDEN
))
143 if (sinfo
->de
->attr
& ATTR_HIDDEN
)
153 * Compute the hash for the msdos name corresponding to the dentry.
154 * Note: if the name is invalid, we leave the hash code unchanged so
155 * that the existing dentry can be used. The msdos fs routines will
156 * return ENOENT or EINVAL as appropriate.
158 static int msdos_hash(struct dentry
*dentry
, struct qstr
*qstr
)
160 struct fat_mount_options
*options
= &MSDOS_SB(dentry
->d_sb
)->options
;
161 unsigned char msdos_name
[MSDOS_NAME
];
164 error
= msdos_format_name(qstr
->name
, qstr
->len
, msdos_name
, options
);
166 qstr
->hash
= full_name_hash(msdos_name
, MSDOS_NAME
);
171 * Compare two msdos names. If either of the names are invalid,
172 * we fall back to doing the standard name comparison.
174 static int msdos_cmp(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
176 struct fat_mount_options
*options
= &MSDOS_SB(dentry
->d_sb
)->options
;
177 unsigned char a_msdos_name
[MSDOS_NAME
], b_msdos_name
[MSDOS_NAME
];
180 error
= msdos_format_name(a
->name
, a
->len
, a_msdos_name
, options
);
183 error
= msdos_format_name(b
->name
, b
->len
, b_msdos_name
, options
);
186 error
= memcmp(a_msdos_name
, b_msdos_name
, MSDOS_NAME
);
192 if (a
->len
== b
->len
)
193 error
= memcmp(a
->name
, b
->name
, a
->len
);
197 static struct dentry_operations msdos_dentry_operations
= {
198 .d_hash
= msdos_hash
,
199 .d_compare
= msdos_cmp
,
203 * AV. Wrappers for FAT sb operations. Is it wise?
206 /***** Get inode using directory and name */
207 static struct dentry
*msdos_lookup(struct inode
*dir
, struct dentry
*dentry
,
208 struct nameidata
*nd
)
210 struct super_block
*sb
= dir
->i_sb
;
211 struct fat_slot_info sinfo
;
212 struct inode
*inode
= NULL
;
215 dentry
->d_op
= &msdos_dentry_operations
;
218 res
= msdos_find(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &sinfo
);
223 inode
= fat_build_inode(sb
, sinfo
.de
, sinfo
.i_pos
);
226 res
= PTR_ERR(inode
);
231 dentry
= d_splice_alias(inode
, dentry
);
233 dentry
->d_op
= &msdos_dentry_operations
;
241 /***** Creates a directory entry (name is already formatted). */
242 static int msdos_add_entry(struct inode
*dir
, const unsigned char *name
,
243 int is_dir
, int is_hid
, int cluster
,
244 struct timespec
*ts
, struct fat_slot_info
*sinfo
)
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_date_unix2dos(ts
->tv_sec
, &time
, &date
);
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(dotdot_bh
);
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(dotdot_bh
);
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_panic(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
)
667 res
= fat_fill_super(sb
, data
, silent
, &msdos_dir_inode_operations
, 0);
671 sb
->s_flags
|= MS_NOATIME
;
672 sb
->s_root
->d_op
= &msdos_dentry_operations
;
676 static int msdos_get_sb(struct file_system_type
*fs_type
,
677 int flags
, const char *dev_name
,
678 void *data
, struct vfsmount
*mnt
)
680 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, msdos_fill_super
,
684 static struct file_system_type msdos_fs_type
= {
685 .owner
= THIS_MODULE
,
687 .get_sb
= msdos_get_sb
,
688 .kill_sb
= kill_block_super
,
689 .fs_flags
= FS_REQUIRES_DEV
,
692 static int __init
init_msdos_fs(void)
694 return register_filesystem(&msdos_fs_type
);
697 static void __exit
exit_msdos_fs(void)
699 unregister_filesystem(&msdos_fs_type
);
702 MODULE_LICENSE("GPL");
703 MODULE_AUTHOR("Werner Almesberger");
704 MODULE_DESCRIPTION("MS-DOS filesystem support");
706 module_init(init_msdos_fs
)
707 module_exit(exit_msdos_fs
)