aboutsummaryrefslogtreecommitdiffstats
path: root/fs/vfat/namei.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/vfat/namei.c')
-rw-r--r--fs/vfat/namei.c1082
1 files changed, 1082 insertions, 0 deletions
diff --git a/fs/vfat/namei.c b/fs/vfat/namei.c
new file mode 100644
index 000000000000..1c6f6b57ef1c
--- /dev/null
+++ b/fs/vfat/namei.c
@@ -0,0 +1,1082 @@
1/*
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 */
624 for (cksum = i = 0; i < 11; i++)
625 cksum = (((cksum&1)<<7)|((cksum&0xfe)>>1)) + msdos_name[i];
626
627 *nr_slots = usize / 13;
628 for (ps = slots, i = *nr_slots; i > 0; i--, ps++) {
629 ps->id = i;
630 ps->attr = ATTR_EXT;
631 ps->reserved = 0;
632 ps->alias_checksum = cksum;
633 ps->start = 0;
634 offset = (i - 1) * 13;
635 fatwchar_to16(ps->name0_4, uname + offset, 5);
636 fatwchar_to16(ps->name5_10, uname + offset + 5, 6);
637 fatwchar_to16(ps->name11_12, uname + offset + 11, 2);
638 }
639 slots[0].id |= 0x40;
640 de = (struct msdos_dir_entry *)ps;
641
642shortname:
643 /* build the entry of 8.3 alias name */
644 (*nr_slots)++;
645 memcpy(de->name, msdos_name, MSDOS_NAME);
646 de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
647 de->lcase = lcase;
648 fat_date_unix2dos(ts->tv_sec, &time, &date);
649 de->time = de->ctime = time;
650 de->date = de->cdate = de->adate = date;
651 de->ctime_cs = 0;
652 de->start = cpu_to_le16(cluster);
653 de->starthi = cpu_to_le16(cluster >> 16);
654 de->size = 0;
655out_free:
656 free_page(page);
657 return err;
658}
659
660static int vfat_add_entry(struct inode *dir, struct qstr *qname, int is_dir,
661 int cluster, struct timespec *ts,
662 struct fat_slot_info *sinfo)
663{
664 struct msdos_dir_slot *slots;
665 unsigned int len;
666 int err, nr_slots;
667
668 len = vfat_striptail_len(qname);
669 if (len == 0)
670 return -ENOENT;
671
672 slots = kmalloc(sizeof(*slots) * MSDOS_SLOTS, GFP_KERNEL);
673 if (slots == NULL)
674 return -ENOMEM;
675
676 err = vfat_build_slots(dir, qname->name, len, is_dir, cluster, ts,
677 slots, &nr_slots);
678 if (err)
679 goto cleanup;
680
681 err = fat_add_entries(dir, slots, nr_slots, sinfo);
682 if (err)
683 goto cleanup;
684
685 /* update timestamp */
686 dir->i_ctime = dir->i_mtime = dir->i_atime = *ts;
687 if (IS_DIRSYNC(dir))
688 (void)fat_sync_inode(dir);
689 else
690 mark_inode_dirty(dir);
691cleanup:
692 kfree(slots);
693 return err;
694}
695
696static int vfat_find(struct inode *dir, struct qstr *qname,
697 struct fat_slot_info *sinfo)
698{
699 unsigned int len = vfat_striptail_len(qname);
700 if (len == 0)
701 return -ENOENT;
702 return fat_search_long(dir, qname->name, len, sinfo);
703}
704
705static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
706 struct nameidata *nd)
707{
708 struct super_block *sb = dir->i_sb;
709 struct fat_slot_info sinfo;
710 struct inode *inode = NULL;
711 struct dentry *alias;
712 int err, table;
713
714 lock_kernel();
715 table = (MSDOS_SB(sb)->options.name_check == 's') ? 2 : 0;
716 dentry->d_op = &vfat_dentry_ops[table];
717
718 err = vfat_find(dir, &dentry->d_name, &sinfo);
719 if (err) {
720 table++;
721 goto error;
722 }
723 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
724 brelse(sinfo.bh);
725 if (IS_ERR(inode)) {
726 unlock_kernel();
727 return ERR_PTR(PTR_ERR(inode));
728 }
729 alias = d_find_alias(inode);
730 if (alias) {
731 if (d_invalidate(alias) == 0)
732 dput(alias);
733 else {
734 iput(inode);
735 unlock_kernel();
736 return alias;
737 }
738
739 }
740error:
741 unlock_kernel();
742 dentry->d_op = &vfat_dentry_ops[table];
743 dentry->d_time = dentry->d_parent->d_inode->i_version;
744 dentry = d_splice_alias(inode, dentry);
745 if (dentry) {
746 dentry->d_op = &vfat_dentry_ops[table];
747 dentry->d_time = dentry->d_parent->d_inode->i_version;
748 }
749 return dentry;
750}
751
752static int vfat_create(struct inode *dir, struct dentry *dentry, int mode,
753 struct nameidata *nd)
754{
755 struct super_block *sb = dir->i_sb;
756 struct inode *inode;
757 struct fat_slot_info sinfo;
758 struct timespec ts;
759 int err;
760
761 lock_kernel();
762
763 ts = CURRENT_TIME_SEC;
764 err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
765 if (err)
766 goto out;
767 dir->i_version++;
768
769 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
770 brelse(sinfo.bh);
771 if (IS_ERR(inode)) {
772 err = PTR_ERR(inode);
773 goto out;
774 }
775 inode->i_version++;
776 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
777 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
778
779 dentry->d_time = dentry->d_parent->d_inode->i_version;
780 d_instantiate(dentry, inode);
781out:
782 unlock_kernel();
783 return err;
784}
785
786static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
787{
788 struct inode *inode = dentry->d_inode;
789 struct fat_slot_info sinfo;
790 int err;
791
792 lock_kernel();
793
794 err = fat_dir_empty(inode);
795 if (err)
796 goto out;
797 err = vfat_find(dir, &dentry->d_name, &sinfo);
798 if (err)
799 goto out;
800
801 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
802 if (err)
803 goto out;
804 dir->i_nlink--;
805
806 inode->i_nlink = 0;
807 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
808 fat_detach(inode);
809out:
810 unlock_kernel();
811
812 return err;
813}
814
815static int vfat_unlink(struct inode *dir, struct dentry *dentry)
816{
817 struct inode *inode = dentry->d_inode;
818 struct fat_slot_info sinfo;
819 int err;
820
821 lock_kernel();
822
823 err = vfat_find(dir, &dentry->d_name, &sinfo);
824 if (err)
825 goto out;
826
827 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
828 if (err)
829 goto out;
830 inode->i_nlink = 0;
831 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
832 fat_detach(inode);
833out:
834 unlock_kernel();
835
836 return err;
837}
838
839static int vfat_mkdir(struct inode *dir, struct dentry *dentry, int mode)
840{
841 struct super_block *sb = dir->i_sb;
842 struct inode *inode;
843 struct fat_slot_info sinfo;
844 struct timespec ts;
845 int err, cluster;
846
847 lock_kernel();
848
849 ts = CURRENT_TIME_SEC;
850 cluster = fat_alloc_new_dir(dir, &ts);
851 if (cluster < 0) {
852 err = cluster;
853 goto out;
854 }
855 err = vfat_add_entry(dir, &dentry->d_name, 1, cluster, &ts, &sinfo);
856 if (err)
857 goto out_free;
858 dir->i_version++;
859 dir->i_nlink++;
860
861 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
862 brelse(sinfo.bh);
863 if (IS_ERR(inode)) {
864 err = PTR_ERR(inode);
865 /* the directory was completed, just return a error */
866 goto out;
867 }
868 inode->i_version++;
869 inode->i_nlink = 2;
870 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
871 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
872
873 dentry->d_time = dentry->d_parent->d_inode->i_version;
874 d_instantiate(dentry, inode);
875
876 unlock_kernel();
877 return 0;
878
879out_free:
880 fat_free_clusters(dir, cluster);
881out:
882 unlock_kernel();
883 return err;
884}
885
886static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
887 struct inode *new_dir, struct dentry *new_dentry)
888{
889 struct buffer_head *dotdot_bh;
890 struct msdos_dir_entry *dotdot_de;
891 loff_t dotdot_i_pos;
892 struct inode *old_inode, *new_inode;
893 struct fat_slot_info old_sinfo, sinfo;
894 struct timespec ts;
895 int err, is_dir, update_dotdot, corrupt = 0;
896
897 old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
898 old_inode = old_dentry->d_inode;
899 new_inode = new_dentry->d_inode;
900 lock_kernel();
901 err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
902 if (err)
903 goto out;
904
905 is_dir = S_ISDIR(old_inode->i_mode);
906 update_dotdot = (is_dir && old_dir != new_dir);
907 if (update_dotdot) {
908 if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
909 &dotdot_i_pos) < 0) {
910 err = -EIO;
911 goto out;
912 }
913 }
914
915 ts = CURRENT_TIME_SEC;
916 if (new_inode) {
917 err = vfat_find(new_dir, &new_dentry->d_name, &sinfo);
918 if (err)
919 goto out;
920 if (MSDOS_I(new_inode)->i_pos != sinfo.i_pos) {
921 /* WTF??? Cry and fail. */
922 printk(KERN_WARNING "vfat_rename: fs corrupted\n");
923 goto out;
924 }
925
926 if (is_dir) {
927 err = fat_dir_empty(new_inode);
928 if (err)
929 goto out;
930 }
931 fat_detach(new_inode);
932 } else {
933 err = vfat_add_entry(new_dir, &new_dentry->d_name, is_dir, 0,
934 &ts, &sinfo);
935 if (err)
936 goto out;
937 }
938 new_dir->i_version++;
939
940 fat_detach(old_inode);
941 fat_attach(old_inode, sinfo.i_pos);
942 if (IS_DIRSYNC(new_dir)) {
943 err = fat_sync_inode(old_inode);
944 if (err)
945 goto error_inode;
946 } else
947 mark_inode_dirty(old_inode);
948
949 if (update_dotdot) {
950 int start = MSDOS_I(new_dir)->i_logstart;
951 dotdot_de->start = cpu_to_le16(start);
952 dotdot_de->starthi = cpu_to_le16(start >> 16);
953 mark_buffer_dirty(dotdot_bh);
954 if (IS_DIRSYNC(new_dir)) {
955 err = sync_dirty_buffer(dotdot_bh);
956 if (err)
957 goto error_dotdot;
958 }
959 old_dir->i_nlink--;
960 if (!new_inode)
961 new_dir->i_nlink++;
962 }
963
964 err = fat_remove_entries(old_dir, &old_sinfo); /* and releases bh */
965 old_sinfo.bh = NULL;
966 if (err)
967 goto error_dotdot;
968 old_dir->i_version++;
969 old_dir->i_ctime = old_dir->i_mtime = ts;
970 if (IS_DIRSYNC(old_dir))
971 (void)fat_sync_inode(old_dir);
972 else
973 mark_inode_dirty(old_dir);
974
975 if (new_inode) {
976 if (is_dir)
977 new_inode->i_nlink -= 2;
978 else
979 new_inode->i_nlink--;
980 new_inode->i_ctime = ts;
981 }
982out:
983 brelse(sinfo.bh);
984 brelse(dotdot_bh);
985 brelse(old_sinfo.bh);
986 unlock_kernel();
987
988 return err;
989
990error_dotdot:
991 /* data cluster is shared, serious corruption */
992 corrupt = 1;
993
994 if (update_dotdot) {
995 int start = MSDOS_I(old_dir)->i_logstart;
996 dotdot_de->start = cpu_to_le16(start);
997 dotdot_de->starthi = cpu_to_le16(start >> 16);
998 mark_buffer_dirty(dotdot_bh);
999 corrupt |= sync_dirty_buffer(dotdot_bh);
1000 }
1001error_inode:
1002 fat_detach(old_inode);
1003 fat_attach(old_inode, old_sinfo.i_pos);
1004 if (new_inode) {
1005 fat_attach(new_inode, sinfo.i_pos);
1006 if (corrupt)
1007 corrupt |= fat_sync_inode(new_inode);
1008 } else {
1009 /*
1010 * If new entry was not sharing the data cluster, it
1011 * shouldn't be serious corruption.
1012 */
1013 int err2 = fat_remove_entries(new_dir, &sinfo);
1014 if (corrupt)
1015 corrupt |= err2;
1016 sinfo.bh = NULL;
1017 }
1018 if (corrupt < 0) {
1019 fat_fs_panic(new_dir->i_sb,
1020 "%s: Filesystem corrupted (i_pos %lld)",
1021 __FUNCTION__, sinfo.i_pos);
1022 }
1023 goto out;
1024}
1025
1026static struct inode_operations vfat_dir_inode_operations = {
1027 .create = vfat_create,
1028 .lookup = vfat_lookup,
1029 .unlink = vfat_unlink,
1030 .mkdir = vfat_mkdir,
1031 .rmdir = vfat_rmdir,
1032 .rename = vfat_rename,
1033 .setattr = fat_notify_change,
1034};
1035
1036static int vfat_fill_super(struct super_block *sb, void *data, int silent)
1037{
1038 int res;
1039
1040 res = fat_fill_super(sb, data, silent, &vfat_dir_inode_operations, 1);
1041 if (res)
1042 return res;
1043
1044 if (MSDOS_SB(sb)->options.name_check != 's')
1045 sb->s_root->d_op = &vfat_dentry_ops[0];
1046 else
1047 sb->s_root->d_op = &vfat_dentry_ops[2];
1048
1049 return 0;
1050}
1051
1052static struct super_block *vfat_get_sb(struct file_system_type *fs_type,
1053 int flags, const char *dev_name,
1054 void *data)
1055{
1056 return get_sb_bdev(fs_type, flags, dev_name, data, vfat_fill_super);
1057}
1058
1059static struct file_system_type vfat_fs_type = {
1060 .owner = THIS_MODULE,
1061 .name = "vfat",
1062 .get_sb = vfat_get_sb,
1063 .kill_sb = kill_block_super,
1064 .fs_flags = FS_REQUIRES_DEV,
1065};
1066
1067static int __init init_vfat_fs(void)
1068{
1069 return register_filesystem(&vfat_fs_type);
1070}
1071
1072static void __exit exit_vfat_fs(void)
1073{
1074 unregister_filesystem(&vfat_fs_type);
1075}
1076
1077MODULE_LICENSE("GPL");
1078MODULE_DESCRIPTION("VFAT filesystem support");
1079MODULE_AUTHOR("Gordon Chaffee");
1080
1081module_init(init_vfat_fs)
1082module_exit(exit_vfat_fs)
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-07 08:02:08 -0500