blob: ef46939c0c1a9cdaf1fd643806d14bad77270743 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/vfat/namei.c
3 *
4 * Written 1992,1993 by Werner Almesberger
5 *
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.
11 *
12 * Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
13 *
14 * Support Multibyte characters and cleanup by
15 * OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
16 */
17
18#include <linux/module.h>
19
20#include <linux/jiffies.h>
21#include <linux/msdos_fs.h>
22#include <linux/ctype.h>
23#include <linux/slab.h>
24#include <linux/smp_lock.h>
25#include <linux/buffer_head.h>
26#include <linux/namei.h>
27
28static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
29{
30 int ret = 1;
31
32 if (!dentry->d_inode &&
33 nd && !(nd->flags & LOOKUP_CONTINUE) && (nd->flags & LOOKUP_CREATE))
34 /*
35 * negative dentry is dropped, in order to make sure
36 * to use the name which a user desires if this is
37 * create path.
38 */
39 ret = 0;
40 else {
41 spin_lock(&dentry->d_lock);
42 if (dentry->d_time != dentry->d_parent->d_inode->i_version)
43 ret = 0;
44 spin_unlock(&dentry->d_lock);
45 }
46 return ret;
47}
48
49/* returns the length of a struct qstr, ignoring trailing dots */
50static unsigned int vfat_striptail_len(struct qstr *qstr)
51{
52 unsigned int len = qstr->len;
53
54 while (len && qstr->name[len - 1] == '.')
55 len--;
56 return len;
57}
58
59/*
60 * Compute the hash for the vfat name corresponding to the dentry.
61 * Note: if the name is invalid, we leave the hash code unchanged so
62 * that the existing dentry can be used. The vfat fs routines will
63 * return ENOENT or EINVAL as appropriate.
64 */
65static int vfat_hash(struct dentry *dentry, struct qstr *qstr)
66{
67 qstr->hash = full_name_hash(qstr->name, vfat_striptail_len(qstr));
68 return 0;
69}
70
71/*
72 * Compute the hash for the vfat name corresponding to the dentry.
73 * Note: if the name is invalid, we leave the hash code unchanged so
74 * that the existing dentry can be used. The vfat fs routines will
75 * return ENOENT or EINVAL as appropriate.
76 */
77static int vfat_hashi(struct dentry *dentry, struct qstr *qstr)
78{
79 struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
80 const unsigned char *name;
81 unsigned int len;
82 unsigned long hash;
83
84 name = qstr->name;
85 len = vfat_striptail_len(qstr);
86
87 hash = init_name_hash();
88 while (len--)
89 hash = partial_name_hash(nls_tolower(t, *name++), hash);
90 qstr->hash = end_name_hash(hash);
91
92 return 0;
93}
94
95/*
96 * Case insensitive compare of two vfat names.
97 */
98static int vfat_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b)
99{
100 struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
101 unsigned int alen, blen;
102
103 /* A filename cannot end in '.' or we treat it like it has none */
104 alen = vfat_striptail_len(a);
105 blen = vfat_striptail_len(b);
106 if (alen == blen) {
107 if (nls_strnicmp(t, a->name, b->name, alen) == 0)
108 return 0;
109 }
110 return 1;
111}
112
113/*
114 * Case sensitive compare of two vfat names.
115 */
116static int vfat_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
117{
118 unsigned int alen, blen;
119
120 /* A filename cannot end in '.' or we treat it like it has none */
121 alen = vfat_striptail_len(a);
122 blen = vfat_striptail_len(b);
123 if (alen == blen) {
124 if (strncmp(a->name, b->name, alen) == 0)
125 return 0;
126 }
127 return 1;
128}
129
130static struct dentry_operations vfat_dentry_ops[4] = {
131 {
132 .d_hash = vfat_hashi,
133 .d_compare = vfat_cmpi,
134 },
135 {
136 .d_revalidate = vfat_revalidate,
137 .d_hash = vfat_hashi,
138 .d_compare = vfat_cmpi,
139 },
140 {
141 .d_hash = vfat_hash,
142 .d_compare = vfat_cmp,
143 },
144 {
145 .d_revalidate = vfat_revalidate,
146 .d_hash = vfat_hash,
147 .d_compare = vfat_cmp,
148 }
149};
150
151/* Characters that are undesirable in an MS-DOS file name */
152
153static inline wchar_t vfat_bad_char(wchar_t w)
154{
155 return (w < 0x0020)
156 || (w == '*') || (w == '?') || (w == '<') || (w == '>')
157 || (w == '|') || (w == '"') || (w == ':') || (w == '/')
158 || (w == '\\');
159}
160
161static inline wchar_t vfat_replace_char(wchar_t w)
162{
163 return (w == '[') || (w == ']') || (w == ';') || (w == ',')
164 || (w == '+') || (w == '=');
165}
166
167static wchar_t vfat_skip_char(wchar_t w)
168{
169 return (w == '.') || (w == ' ');
170}
171
172static inline int vfat_is_used_badchars(const wchar_t *s, int len)
173{
174 int i;
175
176 for (i = 0; i < len; i++)
177 if (vfat_bad_char(s[i]))
178 return -EINVAL;
179 return 0;
180}
181
182static int vfat_valid_longname(const unsigned char *name, unsigned int len)
183{
184 if (name[len - 1] == ' ')
185 return -EINVAL;
186 if (len >= 256)
187 return -ENAMETOOLONG;
188
189 /* MS-DOS "device special files" */
190 if (len == 3 || (len > 3 && name[3] == '.')) { /* basename == 3 */
191 if (!strnicmp(name, "aux", 3) ||
192 !strnicmp(name, "con", 3) ||
193 !strnicmp(name, "nul", 3) ||
194 !strnicmp(name, "prn", 3))
195 return -EINVAL;
196 }
197 if (len == 4 || (len > 4 && name[4] == '.')) { /* basename == 4 */
198 /* "com1", "com2", ... */
199 if ('1' <= name[3] && name[3] <= '9') {
200 if (!strnicmp(name, "com", 3) ||
201 !strnicmp(name, "lpt", 3))
202 return -EINVAL;
203 }
204 }
205
206 return 0;
207}
208
209static int vfat_find_form(struct inode *dir, unsigned char *name)
210{
211 struct fat_slot_info sinfo;
212 int err = fat_scan(dir, name, &sinfo);
213 if (err)
214 return -ENOENT;
215 brelse(sinfo.bh);
216 return 0;
217}
218
219/*
220 * 1) Valid characters for the 8.3 format alias are any combination of
221 * letters, uppercase alphabets, digits, any of the
222 * following special characters:
223 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
224 * In this case Longfilename is not stored in disk.
225 *
226 * WinNT's Extension:
227 * File name and extension name is contain uppercase/lowercase
228 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
229 *
230 * 2) File name is 8.3 format, but it contain the uppercase and
231 * lowercase char, muliti bytes char, etc. In this case numtail is not
232 * added, but Longfilename is stored.
233 *
234 * 3) When the one except for the above, or the following special
235 * character are contained:
236 * . [ ] ; , + =
237 * numtail is added, and Longfilename must be stored in disk .
238 */
239struct shortname_info {
240 unsigned char lower:1,
241 upper:1,
242 valid:1;
243};
244#define INIT_SHORTNAME_INFO(x) do { \
245 (x)->lower = 1; \
246 (x)->upper = 1; \
247 (x)->valid = 1; \
248} while (0)
249
250static inline int to_shortname_char(struct nls_table *nls,
251 unsigned char *buf, int buf_size,
252 wchar_t *src, struct shortname_info *info)
253{
254 int len;
255
256 if (vfat_skip_char(*src)) {
257 info->valid = 0;
258 return 0;
259 }
260 if (vfat_replace_char(*src)) {
261 info->valid = 0;
262 buf[0] = '_';
263 return 1;
264 }
265
266 len = nls->uni2char(*src, buf, buf_size);
267 if (len <= 0) {
268 info->valid = 0;
269 buf[0] = '_';
270 len = 1;
271 } else if (len == 1) {
272 unsigned char prev = buf[0];
273
274 if (buf[0] >= 0x7F) {
275 info->lower = 0;
276 info->upper = 0;
277 }
278
279 buf[0] = nls_toupper(nls, buf[0]);
280 if (isalpha(buf[0])) {
281 if (buf[0] == prev)
282 info->lower = 0;
283 else
284 info->upper = 0;
285 }
286 } else {
287 info->lower = 0;
288 info->upper = 0;
289 }
290
291 return len;
292}
293
294/*
295 * Given a valid longname, create a unique shortname. Make sure the
296 * shortname does not exist
297 * Returns negative number on error, 0 for a normal
298 * return, and 1 for valid shortname
299 */
300static int vfat_create_shortname(struct inode *dir, struct nls_table *nls,
301 wchar_t *uname, int ulen,
302 unsigned char *name_res, unsigned char *lcase)
303{
304 struct fat_mount_options *opts = &MSDOS_SB(dir->i_sb)->options;
305 wchar_t *ip, *ext_start, *end, *name_start;
306 unsigned char base[9], ext[4], buf[8], *p;
307 unsigned char charbuf[NLS_MAX_CHARSET_SIZE];
308 int chl, chi;
309 int sz = 0, extlen, baselen, i, numtail_baselen, numtail2_baselen;
310 int is_shortname;
311 struct shortname_info base_info, ext_info;
312
313 is_shortname = 1;
314 INIT_SHORTNAME_INFO(&base_info);
315 INIT_SHORTNAME_INFO(&ext_info);
316
317 /* Now, we need to create a shortname from the long name */
318 ext_start = end = &uname[ulen];
319 while (--ext_start >= uname) {
320 if (*ext_start == 0x002E) { /* is `.' */
321 if (ext_start == end - 1) {
322 sz = ulen;
323 ext_start = NULL;
324 }
325 break;
326 }
327 }
328
329 if (ext_start == uname - 1) {
330 sz = ulen;
331 ext_start = NULL;
332 } else if (ext_start) {
333 /*
334 * Names which start with a dot could be just
335 * an extension eg. "...test". In this case Win95
336 * uses the extension as the name and sets no extension.
337 */
338 name_start = &uname[0];
339 while (name_start < ext_start) {
340 if (!vfat_skip_char(*name_start))
341 break;
342 name_start++;
343 }
344 if (name_start != ext_start) {
345 sz = ext_start - uname;
346 ext_start++;
347 } else {
348 sz = ulen;
349 ext_start = NULL;
350 }
351 }
352
353 numtail_baselen = 6;
354 numtail2_baselen = 2;
355 for (baselen = i = 0, p = base, ip = uname; i < sz; i++, ip++) {
356 chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
357 ip, &base_info);
358 if (chl == 0)
359 continue;
360
361 if (baselen < 2 && (baselen + chl) > 2)
362 numtail2_baselen = baselen;
363 if (baselen < 6 && (baselen + chl) > 6)
364 numtail_baselen = baselen;
365 for (chi = 0; chi < chl; chi++) {
366 *p++ = charbuf[chi];
367 baselen++;
368 if (baselen >= 8)
369 break;
370 }
371 if (baselen >= 8) {
372 if ((chi < chl - 1) || (ip + 1) - uname < sz)
373 is_shortname = 0;
374 break;
375 }
376 }
377 if (baselen == 0) {
378 return -EINVAL;
379 }
380
381 extlen = 0;
382 if (ext_start) {
383 for (p = ext, ip = ext_start; extlen < 3 && ip < end; ip++) {
384 chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
385 ip, &ext_info);
386 if (chl == 0)
387 continue;
388
389 if ((extlen + chl) > 3) {
390 is_shortname = 0;
391 break;
392 }
393 for (chi = 0; chi < chl; chi++) {
394 *p++ = charbuf[chi];
395 extlen++;
396 }
397 if (extlen >= 3) {
398 if (ip + 1 != end)
399 is_shortname = 0;
400 break;
401 }
402 }
403 }
404 ext[extlen] = '\0';
405 base[baselen] = '\0';
406
407 /* Yes, it can happen. ".\xe5" would do it. */
408 if (base[0] == DELETED_FLAG)
409 base[0] = 0x05;
410
411 /* OK, at this point we know that base is not longer than 8 symbols,
412 * ext is not longer than 3, base is nonempty, both don't contain
413 * any bad symbols (lowercase transformed to uppercase).
414 */
415
416 memset(name_res, ' ', MSDOS_NAME);
417 memcpy(name_res, base, baselen);
418 memcpy(name_res + 8, ext, extlen);
419 *lcase = 0;
420 if (is_shortname && base_info.valid && ext_info.valid) {
421 if (vfat_find_form(dir, name_res) == 0)
422 return -EEXIST;
423
424 if (opts->shortname & VFAT_SFN_CREATE_WIN95) {
425 return (base_info.upper && ext_info.upper);
426 } else if (opts->shortname & VFAT_SFN_CREATE_WINNT) {
427 if ((base_info.upper || base_info.lower) &&
428 (ext_info.upper || ext_info.lower)) {
429 if (!base_info.upper && base_info.lower)
430 *lcase |= CASE_LOWER_BASE;
431 if (!ext_info.upper && ext_info.lower)
432 *lcase |= CASE_LOWER_EXT;
433 return 1;
434 }
435 return 0;
436 } else {
437 BUG();
438 }
439 }
440
441 if (opts->numtail == 0)
442 if (vfat_find_form(dir, name_res) < 0)
443 return 0;
444
445 /*
446 * Try to find a unique extension. This used to
447 * iterate through all possibilities sequentially,
448 * but that gave extremely bad performance. Windows
449 * only tries a few cases before using random
450 * values for part of the base.
451 */
452
453 if (baselen > 6) {
454 baselen = numtail_baselen;
455 name_res[7] = ' ';
456 }
457 name_res[baselen] = '~';
458 for (i = 1; i < 10; i++) {
459 name_res[baselen + 1] = i + '0';
460 if (vfat_find_form(dir, name_res) < 0)
461 return 0;
462 }
463
464 i = jiffies & 0xffff;
465 sz = (jiffies >> 16) & 0x7;
466 if (baselen > 2) {
467 baselen = numtail2_baselen;
468 name_res[7] = ' ';
469 }
470 name_res[baselen + 4] = '~';
471 name_res[baselen + 5] = '1' + sz;
472 while (1) {
473 sprintf(buf, "%04X", i);
474 memcpy(&name_res[baselen], buf, 4);
475 if (vfat_find_form(dir, name_res) < 0)
476 break;
477 i -= 11;
478 }
479 return 0;
480}
481
482/* Translate a string, including coded sequences into Unicode */
483static int
484xlate_to_uni(const unsigned char *name, int len, unsigned char *outname,
485 int *longlen, int *outlen, int escape, int utf8,
486 struct nls_table *nls)
487{
488 const unsigned char *ip;
489 unsigned char nc;
490 unsigned char *op;
491 unsigned int ec;
492 int i, k, fill;
493 int charlen;
494
495 if (utf8) {
496 int name_len = strlen(name);
497
498 *outlen = utf8_mbstowcs((wchar_t *)outname, name, PAGE_SIZE);
499
500 /*
501 * We stripped '.'s before and set len appropriately,
502 * but utf8_mbstowcs doesn't care about len
503 */
504 *outlen -= (name_len - len);
505
506 op = &outname[*outlen * sizeof(wchar_t)];
507 } else {
508 if (nls) {
509 for (i = 0, ip = name, op = outname, *outlen = 0;
510 i < len && *outlen <= 260;
511 *outlen += 1)
512 {
513 if (escape && (*ip == ':')) {
514 if (i > len - 5)
515 return -EINVAL;
516 ec = 0;
517 for (k = 1; k < 5; k++) {
518 nc = ip[k];
519 ec <<= 4;
520 if (nc >= '0' && nc <= '9') {
521 ec |= nc - '0';
522 continue;
523 }
524 if (nc >= 'a' && nc <= 'f') {
525 ec |= nc - ('a' - 10);
526 continue;
527 }
528 if (nc >= 'A' && nc <= 'F') {
529 ec |= nc - ('A' - 10);
530 continue;
531 }
532 return -EINVAL;
533 }
534 *op++ = ec & 0xFF;
535 *op++ = ec >> 8;
536 ip += 5;
537 i += 5;
538 } else {
539 if ((charlen = nls->char2uni(ip, len - i, (wchar_t *)op)) < 0)
540 return -EINVAL;
541 ip += charlen;
542 i += charlen;
543 op += 2;
544 }
545 }
546 } else {
547 for (i = 0, ip = name, op = outname, *outlen = 0;
548 i < len && *outlen <= 260;
549 i++, *outlen += 1)
550 {
551 *op++ = *ip++;
552 *op++ = 0;
553 }
554 }
555 }
556 if (*outlen > 260)
557 return -ENAMETOOLONG;
558
559 *longlen = *outlen;
560 if (*outlen % 13) {
561 *op++ = 0;
562 *op++ = 0;
563 *outlen += 1;
564 if (*outlen % 13) {
565 fill = 13 - (*outlen % 13);
566 for (i = 0; i < fill; i++) {
567 *op++ = 0xff;
568 *op++ = 0xff;
569 }
570 *outlen += fill;
571 }
572 }
573
574 return 0;
575}
576
577static int vfat_build_slots(struct inode *dir, const unsigned char *name,
578 int len, int is_dir, int cluster,
579 struct timespec *ts,
580 struct msdos_dir_slot *slots, int *nr_slots)
581{
582 struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
583 struct fat_mount_options *opts = &sbi->options;
584 struct msdos_dir_slot *ps;
585 struct msdos_dir_entry *de;
586 unsigned long page;
587 unsigned char cksum, lcase;
588 unsigned char msdos_name[MSDOS_NAME];
589 wchar_t *uname;
590 __le16 time, date;
591 int err, ulen, usize, i;
592 loff_t offset;
593
594 *nr_slots = 0;
595 err = vfat_valid_longname(name, len);
596 if (err)
597 return err;
598
599 page = __get_free_page(GFP_KERNEL);
600 if (!page)
601 return -ENOMEM;
602
603 uname = (wchar_t *)page;
604 err = xlate_to_uni(name, len, (unsigned char *)uname, &ulen, &usize,
605 opts->unicode_xlate, opts->utf8, sbi->nls_io);
606 if (err)
607 goto out_free;
608
609 err = vfat_is_used_badchars(uname, ulen);
610 if (err)
611 goto out_free;
612
613 err = vfat_create_shortname(dir, sbi->nls_disk, uname, ulen,
614 msdos_name, &lcase);
615 if (err < 0)
616 goto out_free;
617 else if (err == 1) {
618 de = (struct msdos_dir_entry *)slots;
619 err = 0;
620 goto shortname;
621 }
622
623 /* build the entry of long file name */
OGAWA Hirofumi451cbaa2005-10-30 15:03:49 -0800624 cksum = fat_checksum(msdos_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626 *nr_slots = usize / 13;
627 for (ps = slots, i = *nr_slots; i > 0; i--, ps++) {
628 ps->id = i;
629 ps->attr = ATTR_EXT;
630 ps->reserved = 0;
631 ps->alias_checksum = cksum;
632 ps->start = 0;
633 offset = (i - 1) * 13;
634 fatwchar_to16(ps->name0_4, uname + offset, 5);
635 fatwchar_to16(ps->name5_10, uname + offset + 5, 6);
636 fatwchar_to16(ps->name11_12, uname + offset + 11, 2);
637 }
638 slots[0].id |= 0x40;
639 de = (struct msdos_dir_entry *)ps;
640
641shortname:
642 /* build the entry of 8.3 alias name */
643 (*nr_slots)++;
644 memcpy(de->name, msdos_name, MSDOS_NAME);
645 de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
646 de->lcase = lcase;
647 fat_date_unix2dos(ts->tv_sec, &time, &date);
648 de->time = de->ctime = time;
649 de->date = de->cdate = de->adate = date;
650 de->ctime_cs = 0;
651 de->start = cpu_to_le16(cluster);
652 de->starthi = cpu_to_le16(cluster >> 16);
653 de->size = 0;
654out_free:
655 free_page(page);
656 return err;
657}
658
659static int vfat_add_entry(struct inode *dir, struct qstr *qname, int is_dir,
660 int cluster, struct timespec *ts,
661 struct fat_slot_info *sinfo)
662{
663 struct msdos_dir_slot *slots;
664 unsigned int len;
665 int err, nr_slots;
666
667 len = vfat_striptail_len(qname);
668 if (len == 0)
669 return -ENOENT;
670
671 slots = kmalloc(sizeof(*slots) * MSDOS_SLOTS, GFP_KERNEL);
672 if (slots == NULL)
673 return -ENOMEM;
674
675 err = vfat_build_slots(dir, qname->name, len, is_dir, cluster, ts,
676 slots, &nr_slots);
677 if (err)
678 goto cleanup;
679
680 err = fat_add_entries(dir, slots, nr_slots, sinfo);
681 if (err)
682 goto cleanup;
683
684 /* update timestamp */
685 dir->i_ctime = dir->i_mtime = dir->i_atime = *ts;
686 if (IS_DIRSYNC(dir))
687 (void)fat_sync_inode(dir);
688 else
689 mark_inode_dirty(dir);
690cleanup:
691 kfree(slots);
692 return err;
693}
694
695static int vfat_find(struct inode *dir, struct qstr *qname,
696 struct fat_slot_info *sinfo)
697{
698 unsigned int len = vfat_striptail_len(qname);
699 if (len == 0)
700 return -ENOENT;
701 return fat_search_long(dir, qname->name, len, sinfo);
702}
703
704static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
705 struct nameidata *nd)
706{
707 struct super_block *sb = dir->i_sb;
708 struct fat_slot_info sinfo;
709 struct inode *inode = NULL;
710 struct dentry *alias;
711 int err, table;
712
713 lock_kernel();
714 table = (MSDOS_SB(sb)->options.name_check == 's') ? 2 : 0;
715 dentry->d_op = &vfat_dentry_ops[table];
716
717 err = vfat_find(dir, &dentry->d_name, &sinfo);
718 if (err) {
719 table++;
720 goto error;
721 }
722 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
723 brelse(sinfo.bh);
724 if (IS_ERR(inode)) {
725 unlock_kernel();
726 return ERR_PTR(PTR_ERR(inode));
727 }
728 alias = d_find_alias(inode);
729 if (alias) {
730 if (d_invalidate(alias) == 0)
731 dput(alias);
732 else {
733 iput(inode);
734 unlock_kernel();
735 return alias;
736 }
737
738 }
739error:
740 unlock_kernel();
741 dentry->d_op = &vfat_dentry_ops[table];
742 dentry->d_time = dentry->d_parent->d_inode->i_version;
743 dentry = d_splice_alias(inode, dentry);
744 if (dentry) {
745 dentry->d_op = &vfat_dentry_ops[table];
746 dentry->d_time = dentry->d_parent->d_inode->i_version;
747 }
748 return dentry;
749}
750
751static int vfat_create(struct inode *dir, struct dentry *dentry, int mode,
752 struct nameidata *nd)
753{
754 struct super_block *sb = dir->i_sb;
755 struct inode *inode;
756 struct fat_slot_info sinfo;
757 struct timespec ts;
758 int err;
759
760 lock_kernel();
761
762 ts = CURRENT_TIME_SEC;
763 err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
764 if (err)
765 goto out;
766 dir->i_version++;
767
768 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
769 brelse(sinfo.bh);
770 if (IS_ERR(inode)) {
771 err = PTR_ERR(inode);
772 goto out;
773 }
774 inode->i_version++;
775 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
776 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
777
778 dentry->d_time = dentry->d_parent->d_inode->i_version;
779 d_instantiate(dentry, inode);
780out:
781 unlock_kernel();
782 return err;
783}
784
785static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
786{
787 struct inode *inode = dentry->d_inode;
788 struct fat_slot_info sinfo;
789 int err;
790
791 lock_kernel();
792
793 err = fat_dir_empty(inode);
794 if (err)
795 goto out;
796 err = vfat_find(dir, &dentry->d_name, &sinfo);
797 if (err)
798 goto out;
799
800 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
801 if (err)
802 goto out;
803 dir->i_nlink--;
804
805 inode->i_nlink = 0;
806 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
807 fat_detach(inode);
808out:
809 unlock_kernel();
810
811 return err;
812}
813
814static int vfat_unlink(struct inode *dir, struct dentry *dentry)
815{
816 struct inode *inode = dentry->d_inode;
817 struct fat_slot_info sinfo;
818 int err;
819
820 lock_kernel();
821
822 err = vfat_find(dir, &dentry->d_name, &sinfo);
823 if (err)
824 goto out;
825
826 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
827 if (err)
828 goto out;
829 inode->i_nlink = 0;
830 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
831 fat_detach(inode);
832out:
833 unlock_kernel();
834
835 return err;
836}
837
838static int vfat_mkdir(struct inode *dir, struct dentry *dentry, int mode)
839{
840 struct super_block *sb = dir->i_sb;
841 struct inode *inode;
842 struct fat_slot_info sinfo;
843 struct timespec ts;
844 int err, cluster;
845
846 lock_kernel();
847
848 ts = CURRENT_TIME_SEC;
849 cluster = fat_alloc_new_dir(dir, &ts);
850 if (cluster < 0) {
851 err = cluster;
852 goto out;
853 }
854 err = vfat_add_entry(dir, &dentry->d_name, 1, cluster, &ts, &sinfo);
855 if (err)
856 goto out_free;
857 dir->i_version++;
858 dir->i_nlink++;
859
860 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
861 brelse(sinfo.bh);
862 if (IS_ERR(inode)) {
863 err = PTR_ERR(inode);
864 /* the directory was completed, just return a error */
865 goto out;
866 }
867 inode->i_version++;
868 inode->i_nlink = 2;
869 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
870 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
871
872 dentry->d_time = dentry->d_parent->d_inode->i_version;
873 d_instantiate(dentry, inode);
874
875 unlock_kernel();
876 return 0;
877
878out_free:
879 fat_free_clusters(dir, cluster);
880out:
881 unlock_kernel();
882 return err;
883}
884
885static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
886 struct inode *new_dir, struct dentry *new_dentry)
887{
888 struct buffer_head *dotdot_bh;
889 struct msdos_dir_entry *dotdot_de;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 struct inode *old_inode, *new_inode;
891 struct fat_slot_info old_sinfo, sinfo;
892 struct timespec ts;
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800893 loff_t dotdot_i_pos, new_i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 int err, is_dir, update_dotdot, corrupt = 0;
895
896 old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
897 old_inode = old_dentry->d_inode;
898 new_inode = new_dentry->d_inode;
899 lock_kernel();
900 err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
901 if (err)
902 goto out;
903
904 is_dir = S_ISDIR(old_inode->i_mode);
905 update_dotdot = (is_dir && old_dir != new_dir);
906 if (update_dotdot) {
907 if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
908 &dotdot_i_pos) < 0) {
909 err = -EIO;
910 goto out;
911 }
912 }
913
914 ts = CURRENT_TIME_SEC;
915 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 if (is_dir) {
917 err = fat_dir_empty(new_inode);
918 if (err)
919 goto out;
920 }
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800921 new_i_pos = MSDOS_I(new_inode)->i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 fat_detach(new_inode);
923 } else {
924 err = vfat_add_entry(new_dir, &new_dentry->d_name, is_dir, 0,
925 &ts, &sinfo);
926 if (err)
927 goto out;
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800928 new_i_pos = sinfo.i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 }
930 new_dir->i_version++;
931
932 fat_detach(old_inode);
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800933 fat_attach(old_inode, new_i_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (IS_DIRSYNC(new_dir)) {
935 err = fat_sync_inode(old_inode);
936 if (err)
937 goto error_inode;
938 } else
939 mark_inode_dirty(old_inode);
940
941 if (update_dotdot) {
942 int start = MSDOS_I(new_dir)->i_logstart;
943 dotdot_de->start = cpu_to_le16(start);
944 dotdot_de->starthi = cpu_to_le16(start >> 16);
945 mark_buffer_dirty(dotdot_bh);
946 if (IS_DIRSYNC(new_dir)) {
947 err = sync_dirty_buffer(dotdot_bh);
948 if (err)
949 goto error_dotdot;
950 }
951 old_dir->i_nlink--;
952 if (!new_inode)
953 new_dir->i_nlink++;
954 }
955
956 err = fat_remove_entries(old_dir, &old_sinfo); /* and releases bh */
957 old_sinfo.bh = NULL;
958 if (err)
959 goto error_dotdot;
960 old_dir->i_version++;
961 old_dir->i_ctime = old_dir->i_mtime = ts;
962 if (IS_DIRSYNC(old_dir))
963 (void)fat_sync_inode(old_dir);
964 else
965 mark_inode_dirty(old_dir);
966
967 if (new_inode) {
968 if (is_dir)
969 new_inode->i_nlink -= 2;
970 else
971 new_inode->i_nlink--;
972 new_inode->i_ctime = ts;
973 }
974out:
975 brelse(sinfo.bh);
976 brelse(dotdot_bh);
977 brelse(old_sinfo.bh);
978 unlock_kernel();
979
980 return err;
981
982error_dotdot:
983 /* data cluster is shared, serious corruption */
984 corrupt = 1;
985
986 if (update_dotdot) {
987 int start = MSDOS_I(old_dir)->i_logstart;
988 dotdot_de->start = cpu_to_le16(start);
989 dotdot_de->starthi = cpu_to_le16(start >> 16);
990 mark_buffer_dirty(dotdot_bh);
991 corrupt |= sync_dirty_buffer(dotdot_bh);
992 }
993error_inode:
994 fat_detach(old_inode);
995 fat_attach(old_inode, old_sinfo.i_pos);
996 if (new_inode) {
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800997 fat_attach(new_inode, new_i_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (corrupt)
999 corrupt |= fat_sync_inode(new_inode);
1000 } else {
1001 /*
1002 * If new entry was not sharing the data cluster, it
1003 * shouldn't be serious corruption.
1004 */
1005 int err2 = fat_remove_entries(new_dir, &sinfo);
1006 if (corrupt)
1007 corrupt |= err2;
1008 sinfo.bh = NULL;
1009 }
1010 if (corrupt < 0) {
1011 fat_fs_panic(new_dir->i_sb,
1012 "%s: Filesystem corrupted (i_pos %lld)",
1013 __FUNCTION__, sinfo.i_pos);
1014 }
1015 goto out;
1016}
1017
1018static struct inode_operations vfat_dir_inode_operations = {
1019 .create = vfat_create,
1020 .lookup = vfat_lookup,
1021 .unlink = vfat_unlink,
1022 .mkdir = vfat_mkdir,
1023 .rmdir = vfat_rmdir,
1024 .rename = vfat_rename,
1025 .setattr = fat_notify_change,
1026};
1027
1028static int vfat_fill_super(struct super_block *sb, void *data, int silent)
1029{
1030 int res;
1031
1032 res = fat_fill_super(sb, data, silent, &vfat_dir_inode_operations, 1);
1033 if (res)
1034 return res;
1035
1036 if (MSDOS_SB(sb)->options.name_check != 's')
1037 sb->s_root->d_op = &vfat_dentry_ops[0];
1038 else
1039 sb->s_root->d_op = &vfat_dentry_ops[2];
1040
1041 return 0;
1042}
1043
1044static struct super_block *vfat_get_sb(struct file_system_type *fs_type,
1045 int flags, const char *dev_name,
1046 void *data)
1047{
1048 return get_sb_bdev(fs_type, flags, dev_name, data, vfat_fill_super);
1049}
1050
1051static struct file_system_type vfat_fs_type = {
1052 .owner = THIS_MODULE,
1053 .name = "vfat",
1054 .get_sb = vfat_get_sb,
1055 .kill_sb = kill_block_super,
1056 .fs_flags = FS_REQUIRES_DEV,
1057};
1058
1059static int __init init_vfat_fs(void)
1060{
1061 return register_filesystem(&vfat_fs_type);
1062}
1063
1064static void __exit exit_vfat_fs(void)
1065{
1066 unregister_filesystem(&vfat_fs_type);
1067}
1068
1069MODULE_LICENSE("GPL");
1070MODULE_DESCRIPTION("VFAT filesystem support");
1071MODULE_AUTHOR("Gordon Chaffee");
1072
1073module_init(init_vfat_fs)
1074module_exit(exit_vfat_fs)