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