Merge branch 'fix/hda' into for-linus
[firefly-linux-kernel-4.4.55.git] / fs / fat / namei_msdos.c
1 /*
2  *  linux/fs/msdos/namei.c
3  *
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
7  */
8
9 #include <linux/module.h>
10 #include <linux/time.h>
11 #include <linux/buffer_head.h>
12 #include "fat.h"
13
14 /* Characters that are undesirable in an MS-DOS file name */
15 static unsigned char bad_chars[] = "*?<>|\"";
16 static unsigned char bad_if_strict[] = "+=,; ";
17
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)
21         /*
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)
26          */
27 {
28         unsigned char *walk;
29         unsigned char c;
30         int space;
31
32         if (name[0] == '.') {   /* dotfile because . and .. already done */
33                 if (opts->dotsOK) {
34                         /* Get rid of dot - test for it elsewhere */
35                         name++;
36                         len--;
37                 } else
38                         return -EINVAL;
39         }
40         /*
41          * disallow names that _really_ start with a dot
42          */
43         space = 1;
44         c = 0;
45         for (walk = res; len && walk - res < 8; walk++) {
46                 c = *name++;
47                 len--;
48                 if (opts->name_check != 'r' && strchr(bad_chars, c))
49                         return -EINVAL;
50                 if (opts->name_check == 's' && strchr(bad_if_strict, c))
51                         return -EINVAL;
52                 if (c >= 'A' && c <= 'Z' && opts->name_check == 's')
53                         return -EINVAL;
54                 if (c < ' ' || c == ':' || c == '\\')
55                         return -EINVAL;
56         /*
57          * 0xE5 is legal as a first character, but we must substitute
58          * 0x05 because 0xE5 marks deleted files.  Yes, DOS really
59          * does this.
60          * It seems that Microsoft hacked DOS to support non-US
61          * characters after the 0xE5 character was already in use to
62          * mark deleted files.
63          */
64                 if ((res == walk) && (c == 0xE5))
65                         c = 0x05;
66                 if (c == '.')
67                         break;
68                 space = (c == ' ');
69                 *walk = (!opts->nocase && c >= 'a' && c <= 'z') ? c - 32 : c;
70         }
71         if (space)
72                 return -EINVAL;
73         if (opts->name_check == 's' && len && c != '.') {
74                 c = *name++;
75                 len--;
76                 if (c != '.')
77                         return -EINVAL;
78         }
79         while (c != '.' && len--)
80                 c = *name++;
81         if (c == '.') {
82                 while (walk - res < 8)
83                         *walk++ = ' ';
84                 while (len > 0 && walk - res < MSDOS_NAME) {
85                         c = *name++;
86                         len--;
87                         if (opts->name_check != 'r' && strchr(bad_chars, c))
88                                 return -EINVAL;
89                         if (opts->name_check == 's' &&
90                             strchr(bad_if_strict, c))
91                                 return -EINVAL;
92                         if (c < ' ' || c == ':' || c == '\\')
93                                 return -EINVAL;
94                         if (c == '.') {
95                                 if (opts->name_check == 's')
96                                         return -EINVAL;
97                                 break;
98                         }
99                         if (c >= 'A' && c <= 'Z' && opts->name_check == 's')
100                                 return -EINVAL;
101                         space = c == ' ';
102                         if (!opts->nocase && c >= 'a' && c <= 'z')
103                                 *walk++ = c - 32;
104                         else
105                                 *walk++ = c;
106                 }
107                 if (space)
108                         return -EINVAL;
109                 if (opts->name_check == 's' && len)
110                         return -EINVAL;
111         }
112         while (walk - res < MSDOS_NAME)
113                 *walk++ = ' ';
114
115         return 0;
116 }
117
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)
121 {
122         struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
123         unsigned char msdos_name[MSDOS_NAME];
124         int err;
125
126         err = msdos_format_name(name, len, msdos_name, &sbi->options);
127         if (err)
128                 return -ENOENT;
129
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))
134                                 err = -ENOENT;
135                 } else {
136                         if (sinfo->de->attr & ATTR_HIDDEN)
137                                 err = -ENOENT;
138                 }
139                 if (err)
140                         brelse(sinfo->bh);
141         }
142         return err;
143 }
144
145 /*
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.
150  */
151 static int msdos_hash(struct dentry *dentry, struct qstr *qstr)
152 {
153         struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
154         unsigned char msdos_name[MSDOS_NAME];
155         int error;
156
157         error = msdos_format_name(qstr->name, qstr->len, msdos_name, options);
158         if (!error)
159                 qstr->hash = full_name_hash(msdos_name, MSDOS_NAME);
160         return 0;
161 }
162
163 /*
164  * Compare two msdos names. If either of the names are invalid,
165  * we fall back to doing the standard name comparison.
166  */
167 static int msdos_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
168 {
169         struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
170         unsigned char a_msdos_name[MSDOS_NAME], b_msdos_name[MSDOS_NAME];
171         int error;
172
173         error = msdos_format_name(a->name, a->len, a_msdos_name, options);
174         if (error)
175                 goto old_compare;
176         error = msdos_format_name(b->name, b->len, b_msdos_name, options);
177         if (error)
178                 goto old_compare;
179         error = memcmp(a_msdos_name, b_msdos_name, MSDOS_NAME);
180 out:
181         return error;
182
183 old_compare:
184         error = 1;
185         if (a->len == b->len)
186                 error = memcmp(a->name, b->name, a->len);
187         goto out;
188 }
189
190 static const struct dentry_operations msdos_dentry_operations = {
191         .d_hash         = msdos_hash,
192         .d_compare      = msdos_cmp,
193 };
194
195 /*
196  * AV. Wrappers for FAT sb operations. Is it wise?
197  */
198
199 /***** Get inode using directory and name */
200 static struct dentry *msdos_lookup(struct inode *dir, struct dentry *dentry,
201                                    struct nameidata *nd)
202 {
203         struct super_block *sb = dir->i_sb;
204         struct fat_slot_info sinfo;
205         struct inode *inode;
206         int err;
207
208         lock_super(sb);
209
210         err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
211         if (err) {
212                 if (err == -ENOENT) {
213                         inode = NULL;
214                         goto out;
215                 }
216                 goto error;
217         }
218
219         inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
220         brelse(sinfo.bh);
221         if (IS_ERR(inode)) {
222                 err = PTR_ERR(inode);
223                 goto error;
224         }
225 out:
226         unlock_super(sb);
227         dentry->d_op = &msdos_dentry_operations;
228         dentry = d_splice_alias(inode, dentry);
229         if (dentry)
230                 dentry->d_op = &msdos_dentry_operations;
231         return dentry;
232
233 error:
234         unlock_super(sb);
235         return ERR_PTR(err);
236 }
237
238 /***** Creates a directory entry (name is already formatted). */
239 static int msdos_add_entry(struct inode *dir, const unsigned char *name,
240                            int is_dir, int is_hid, int cluster,
241                            struct timespec *ts, struct fat_slot_info *sinfo)
242 {
243         struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
244         struct msdos_dir_entry de;
245         __le16 time, date;
246         int err;
247
248         memcpy(de.name, name, MSDOS_NAME);
249         de.attr = is_dir ? ATTR_DIR : ATTR_ARCH;
250         if (is_hid)
251                 de.attr |= ATTR_HIDDEN;
252         de.lcase = 0;
253         fat_time_unix2fat(sbi, ts, &time, &date, NULL);
254         de.cdate = de.adate = 0;
255         de.ctime = 0;
256         de.ctime_cs = 0;
257         de.time = time;
258         de.date = date;
259         de.start = cpu_to_le16(cluster);
260         de.starthi = cpu_to_le16(cluster >> 16);
261         de.size = 0;
262
263         err = fat_add_entries(dir, &de, 1, sinfo);
264         if (err)
265                 return err;
266
267         dir->i_ctime = dir->i_mtime = *ts;
268         if (IS_DIRSYNC(dir))
269                 (void)fat_sync_inode(dir);
270         else
271                 mark_inode_dirty(dir);
272
273         return 0;
274 }
275
276 /***** Create a file */
277 static int msdos_create(struct inode *dir, struct dentry *dentry, int mode,
278                         struct nameidata *nd)
279 {
280         struct super_block *sb = dir->i_sb;
281         struct inode *inode = NULL;
282         struct fat_slot_info sinfo;
283         struct timespec ts;
284         unsigned char msdos_name[MSDOS_NAME];
285         int err, is_hid;
286
287         lock_super(sb);
288
289         err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
290                                 msdos_name, &MSDOS_SB(sb)->options);
291         if (err)
292                 goto out;
293         is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.');
294         /* Have to do it due to foo vs. .foo conflicts */
295         if (!fat_scan(dir, msdos_name, &sinfo)) {
296                 brelse(sinfo.bh);
297                 err = -EINVAL;
298                 goto out;
299         }
300
301         ts = CURRENT_TIME_SEC;
302         err = msdos_add_entry(dir, msdos_name, 0, is_hid, 0, &ts, &sinfo);
303         if (err)
304                 goto out;
305         inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
306         brelse(sinfo.bh);
307         if (IS_ERR(inode)) {
308                 err = PTR_ERR(inode);
309                 goto out;
310         }
311         inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
312         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
313
314         d_instantiate(dentry, inode);
315 out:
316         unlock_super(sb);
317         if (!err)
318                 err = fat_flush_inodes(sb, dir, inode);
319         return err;
320 }
321
322 /***** Remove a directory */
323 static int msdos_rmdir(struct inode *dir, struct dentry *dentry)
324 {
325         struct super_block *sb = dir->i_sb;
326         struct inode *inode = dentry->d_inode;
327         struct fat_slot_info sinfo;
328         int err;
329
330         lock_super(sb);
331         /*
332          * Check whether the directory is not in use, then check
333          * whether it is empty.
334          */
335         err = fat_dir_empty(inode);
336         if (err)
337                 goto out;
338         err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
339         if (err)
340                 goto out;
341
342         err = fat_remove_entries(dir, &sinfo);  /* and releases bh */
343         if (err)
344                 goto out;
345         drop_nlink(dir);
346
347         clear_nlink(inode);
348         inode->i_ctime = CURRENT_TIME_SEC;
349         fat_detach(inode);
350 out:
351         unlock_super(sb);
352         if (!err)
353                 err = fat_flush_inodes(sb, dir, inode);
354
355         return err;
356 }
357
358 /***** Make a directory */
359 static int msdos_mkdir(struct inode *dir, struct dentry *dentry, int mode)
360 {
361         struct super_block *sb = dir->i_sb;
362         struct fat_slot_info sinfo;
363         struct inode *inode;
364         unsigned char msdos_name[MSDOS_NAME];
365         struct timespec ts;
366         int err, is_hid, cluster;
367
368         lock_super(sb);
369
370         err = msdos_format_name(dentry->d_name.name, dentry->d_name.len,
371                                 msdos_name, &MSDOS_SB(sb)->options);
372         if (err)
373                 goto out;
374         is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.');
375         /* foo vs .foo situation */
376         if (!fat_scan(dir, msdos_name, &sinfo)) {
377                 brelse(sinfo.bh);
378                 err = -EINVAL;
379                 goto out;
380         }
381
382         ts = CURRENT_TIME_SEC;
383         cluster = fat_alloc_new_dir(dir, &ts);
384         if (cluster < 0) {
385                 err = cluster;
386                 goto out;
387         }
388         err = msdos_add_entry(dir, msdos_name, 1, is_hid, cluster, &ts, &sinfo);
389         if (err)
390                 goto out_free;
391         inc_nlink(dir);
392
393         inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
394         brelse(sinfo.bh);
395         if (IS_ERR(inode)) {
396                 err = PTR_ERR(inode);
397                 /* the directory was completed, just return a error */
398                 goto out;
399         }
400         inode->i_nlink = 2;
401         inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
402         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
403
404         d_instantiate(dentry, inode);
405
406         unlock_super(sb);
407         fat_flush_inodes(sb, dir, inode);
408         return 0;
409
410 out_free:
411         fat_free_clusters(dir, cluster);
412 out:
413         unlock_super(sb);
414         return err;
415 }
416
417 /***** Unlink a file */
418 static int msdos_unlink(struct inode *dir, struct dentry *dentry)
419 {
420         struct inode *inode = dentry->d_inode;
421         struct super_block *sb= inode->i_sb;
422         struct fat_slot_info sinfo;
423         int err;
424
425         lock_super(sb);
426         err = msdos_find(dir, dentry->d_name.name, dentry->d_name.len, &sinfo);
427         if (err)
428                 goto out;
429
430         err = fat_remove_entries(dir, &sinfo);  /* and releases bh */
431         if (err)
432                 goto out;
433         clear_nlink(inode);
434         inode->i_ctime = CURRENT_TIME_SEC;
435         fat_detach(inode);
436 out:
437         unlock_super(sb);
438         if (!err)
439                 err = fat_flush_inodes(sb, dir, inode);
440
441         return err;
442 }
443
444 static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
445                            struct dentry *old_dentry,
446                            struct inode *new_dir, unsigned char *new_name,
447                            struct dentry *new_dentry, int is_hid)
448 {
449         struct buffer_head *dotdot_bh;
450         struct msdos_dir_entry *dotdot_de;
451         struct inode *old_inode, *new_inode;
452         struct fat_slot_info old_sinfo, sinfo;
453         struct timespec ts;
454         loff_t dotdot_i_pos, new_i_pos;
455         int err, old_attrs, is_dir, update_dotdot, corrupt = 0;
456
457         old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
458         old_inode = old_dentry->d_inode;
459         new_inode = new_dentry->d_inode;
460
461         err = fat_scan(old_dir, old_name, &old_sinfo);
462         if (err) {
463                 err = -EIO;
464                 goto out;
465         }
466
467         is_dir = S_ISDIR(old_inode->i_mode);
468         update_dotdot = (is_dir && old_dir != new_dir);
469         if (update_dotdot) {
470                 if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
471                                          &dotdot_i_pos) < 0) {
472                         err = -EIO;
473                         goto out;
474                 }
475         }
476
477         old_attrs = MSDOS_I(old_inode)->i_attrs;
478         err = fat_scan(new_dir, new_name, &sinfo);
479         if (!err) {
480                 if (!new_inode) {
481                         /* "foo" -> ".foo" case. just change the ATTR_HIDDEN */
482                         if (sinfo.de != old_sinfo.de) {
483                                 err = -EINVAL;
484                                 goto out;
485                         }
486                         if (is_hid)
487                                 MSDOS_I(old_inode)->i_attrs |= ATTR_HIDDEN;
488                         else
489                                 MSDOS_I(old_inode)->i_attrs &= ~ATTR_HIDDEN;
490                         if (IS_DIRSYNC(old_dir)) {
491                                 err = fat_sync_inode(old_inode);
492                                 if (err) {
493                                         MSDOS_I(old_inode)->i_attrs = old_attrs;
494                                         goto out;
495                                 }
496                         } else
497                                 mark_inode_dirty(old_inode);
498
499                         old_dir->i_version++;
500                         old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
501                         if (IS_DIRSYNC(old_dir))
502                                 (void)fat_sync_inode(old_dir);
503                         else
504                                 mark_inode_dirty(old_dir);
505                         goto out;
506                 }
507         }
508
509         ts = CURRENT_TIME_SEC;
510         if (new_inode) {
511                 if (err)
512                         goto out;
513                 if (is_dir) {
514                         err = fat_dir_empty(new_inode);
515                         if (err)
516                                 goto out;
517                 }
518                 new_i_pos = MSDOS_I(new_inode)->i_pos;
519                 fat_detach(new_inode);
520         } else {
521                 err = msdos_add_entry(new_dir, new_name, is_dir, is_hid, 0,
522                                       &ts, &sinfo);
523                 if (err)
524                         goto out;
525                 new_i_pos = sinfo.i_pos;
526         }
527         new_dir->i_version++;
528
529         fat_detach(old_inode);
530         fat_attach(old_inode, new_i_pos);
531         if (is_hid)
532                 MSDOS_I(old_inode)->i_attrs |= ATTR_HIDDEN;
533         else
534                 MSDOS_I(old_inode)->i_attrs &= ~ATTR_HIDDEN;
535         if (IS_DIRSYNC(new_dir)) {
536                 err = fat_sync_inode(old_inode);
537                 if (err)
538                         goto error_inode;
539         } else
540                 mark_inode_dirty(old_inode);
541
542         if (update_dotdot) {
543                 int start = MSDOS_I(new_dir)->i_logstart;
544                 dotdot_de->start = cpu_to_le16(start);
545                 dotdot_de->starthi = cpu_to_le16(start >> 16);
546                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
547                 if (IS_DIRSYNC(new_dir)) {
548                         err = sync_dirty_buffer(dotdot_bh);
549                         if (err)
550                                 goto error_dotdot;
551                 }
552                 drop_nlink(old_dir);
553                 if (!new_inode)
554                         inc_nlink(new_dir);
555         }
556
557         err = fat_remove_entries(old_dir, &old_sinfo);  /* and releases bh */
558         old_sinfo.bh = NULL;
559         if (err)
560                 goto error_dotdot;
561         old_dir->i_version++;
562         old_dir->i_ctime = old_dir->i_mtime = ts;
563         if (IS_DIRSYNC(old_dir))
564                 (void)fat_sync_inode(old_dir);
565         else
566                 mark_inode_dirty(old_dir);
567
568         if (new_inode) {
569                 drop_nlink(new_inode);
570                 if (is_dir)
571                         drop_nlink(new_inode);
572                 new_inode->i_ctime = ts;
573         }
574 out:
575         brelse(sinfo.bh);
576         brelse(dotdot_bh);
577         brelse(old_sinfo.bh);
578         return err;
579
580 error_dotdot:
581         /* data cluster is shared, serious corruption */
582         corrupt = 1;
583
584         if (update_dotdot) {
585                 int start = MSDOS_I(old_dir)->i_logstart;
586                 dotdot_de->start = cpu_to_le16(start);
587                 dotdot_de->starthi = cpu_to_le16(start >> 16);
588                 mark_buffer_dirty_inode(dotdot_bh, old_inode);
589                 corrupt |= sync_dirty_buffer(dotdot_bh);
590         }
591 error_inode:
592         fat_detach(old_inode);
593         fat_attach(old_inode, old_sinfo.i_pos);
594         MSDOS_I(old_inode)->i_attrs = old_attrs;
595         if (new_inode) {
596                 fat_attach(new_inode, new_i_pos);
597                 if (corrupt)
598                         corrupt |= fat_sync_inode(new_inode);
599         } else {
600                 /*
601                  * If new entry was not sharing the data cluster, it
602                  * shouldn't be serious corruption.
603                  */
604                 int err2 = fat_remove_entries(new_dir, &sinfo);
605                 if (corrupt)
606                         corrupt |= err2;
607                 sinfo.bh = NULL;
608         }
609         if (corrupt < 0) {
610                 fat_fs_error(new_dir->i_sb,
611                              "%s: Filesystem corrupted (i_pos %lld)",
612                              __func__, sinfo.i_pos);
613         }
614         goto out;
615 }
616
617 /***** Rename, a wrapper for rename_same_dir & rename_diff_dir */
618 static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry,
619                         struct inode *new_dir, struct dentry *new_dentry)
620 {
621         struct super_block *sb = old_dir->i_sb;
622         unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME];
623         int err, is_hid;
624
625         lock_super(sb);
626
627         err = msdos_format_name(old_dentry->d_name.name,
628                                 old_dentry->d_name.len, old_msdos_name,
629                                 &MSDOS_SB(old_dir->i_sb)->options);
630         if (err)
631                 goto out;
632         err = msdos_format_name(new_dentry->d_name.name,
633                                 new_dentry->d_name.len, new_msdos_name,
634                                 &MSDOS_SB(new_dir->i_sb)->options);
635         if (err)
636                 goto out;
637
638         is_hid =
639              (new_dentry->d_name.name[0] == '.') && (new_msdos_name[0] != '.');
640
641         err = do_msdos_rename(old_dir, old_msdos_name, old_dentry,
642                               new_dir, new_msdos_name, new_dentry, is_hid);
643 out:
644         unlock_super(sb);
645         if (!err)
646                 err = fat_flush_inodes(sb, old_dir, new_dir);
647         return err;
648 }
649
650 static const struct inode_operations msdos_dir_inode_operations = {
651         .create         = msdos_create,
652         .lookup         = msdos_lookup,
653         .unlink         = msdos_unlink,
654         .mkdir          = msdos_mkdir,
655         .rmdir          = msdos_rmdir,
656         .rename         = msdos_rename,
657         .setattr        = fat_setattr,
658         .getattr        = fat_getattr,
659 };
660
661 static int msdos_fill_super(struct super_block *sb, void *data, int silent)
662 {
663         int res;
664
665         res = fat_fill_super(sb, data, silent, &msdos_dir_inode_operations, 0);
666         if (res)
667                 return res;
668
669         sb->s_flags |= MS_NOATIME;
670         sb->s_root->d_op = &msdos_dentry_operations;
671         return 0;
672 }
673
674 static int msdos_get_sb(struct file_system_type *fs_type,
675                         int flags, const char *dev_name,
676                         void *data, struct vfsmount *mnt)
677 {
678         return get_sb_bdev(fs_type, flags, dev_name, data, msdos_fill_super,
679                            mnt);
680 }
681
682 static struct file_system_type msdos_fs_type = {
683         .owner          = THIS_MODULE,
684         .name           = "msdos",
685         .get_sb         = msdos_get_sb,
686         .kill_sb        = kill_block_super,
687         .fs_flags       = FS_REQUIRES_DEV,
688 };
689
690 static int __init init_msdos_fs(void)
691 {
692         return register_filesystem(&msdos_fs_type);
693 }
694
695 static void __exit exit_msdos_fs(void)
696 {
697         unregister_filesystem(&msdos_fs_type);
698 }
699
700 MODULE_LICENSE("GPL");
701 MODULE_AUTHOR("Werner Almesberger");
702 MODULE_DESCRIPTION("MS-DOS filesystem support");
703
704 module_init(init_msdos_fs)
705 module_exit(exit_msdos_fs)