1 /* 2 * linux/fs/fat/inode.c 3 * 4 * Written 1992,1993 by Werner Almesberger 5 * VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner 6 * Rewritten for the constant inumbers support by Al Viro 7 * 8 * Fixes: 9 * 10 * Max Cohan: Fixed invalid FSINFO offset when info_sector is 0 11 */ 12 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/time.h> 16 #include <linux/slab.h> 17 #include <linux/smp_lock.h> 18 #include <linux/seq_file.h> 19 #include <linux/msdos_fs.h> 20 #include <linux/pagemap.h> 21 #include <linux/buffer_head.h> 22 #include <linux/mount.h> 23 #include <linux/vfs.h> 24 #include <linux/parser.h> 25 #include <asm/unaligned.h> 26 27 #ifndef CONFIG_FAT_DEFAULT_IOCHARSET 28 /* if user don't select VFAT, this is undefined. */ 29 #define CONFIG_FAT_DEFAULT_IOCHARSET "" 30 #endif 31 32 static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE; 33 static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET; 34 35 36 static int fat_add_cluster(struct inode *inode) 37 { 38 int err, cluster; 39 40 err = fat_alloc_clusters(inode, &cluster, 1); 41 if (err) 42 return err; 43 /* FIXME: this cluster should be added after data of this 44 * cluster is writed */ 45 err = fat_chain_add(inode, cluster, 1); 46 if (err) 47 fat_free_clusters(inode, cluster); 48 return err; 49 } 50 51 static int fat_get_block(struct inode *inode, sector_t iblock, 52 struct buffer_head *bh_result, int create) 53 { 54 struct super_block *sb = inode->i_sb; 55 sector_t phys; 56 int err; 57 58 err = fat_bmap(inode, iblock, &phys); 59 if (err) 60 return err; 61 if (phys) { 62 map_bh(bh_result, sb, phys); 63 return 0; 64 } 65 if (!create) 66 return 0; 67 if (iblock != MSDOS_I(inode)->mmu_private >> sb->s_blocksize_bits) { 68 fat_fs_panic(sb, "corrupted file size (i_pos %lld, %lld)", 69 MSDOS_I(inode)->i_pos, MSDOS_I(inode)->mmu_private); 70 return -EIO; 71 } 72 if (!((unsigned long)iblock & (MSDOS_SB(sb)->sec_per_clus - 1))) { 73 err = fat_add_cluster(inode); 74 if (err) 75 return err; 76 } 77 MSDOS_I(inode)->mmu_private += sb->s_blocksize; 78 err = fat_bmap(inode, iblock, &phys); 79 if (err) 80 return err; 81 if (!phys) 82 BUG(); 83 set_buffer_new(bh_result); 84 map_bh(bh_result, sb, phys); 85 return 0; 86 } 87 88 static int fat_writepage(struct page *page, struct writeback_control *wbc) 89 { 90 return block_write_full_page(page, fat_get_block, wbc); 91 } 92 93 static int fat_readpage(struct file *file, struct page *page) 94 { 95 return block_read_full_page(page, fat_get_block); 96 } 97 98 static int fat_prepare_write(struct file *file, struct page *page, 99 unsigned from, unsigned to) 100 { 101 return cont_prepare_write(page, from, to, fat_get_block, 102 &MSDOS_I(page->mapping->host)->mmu_private); 103 } 104 105 static sector_t _fat_bmap(struct address_space *mapping, sector_t block) 106 { 107 return generic_block_bmap(mapping, block, fat_get_block); 108 } 109 110 static struct address_space_operations fat_aops = { 111 .readpage = fat_readpage, 112 .writepage = fat_writepage, 113 .sync_page = block_sync_page, 114 .prepare_write = fat_prepare_write, 115 .commit_write = generic_commit_write, 116 .bmap = _fat_bmap 117 }; 118 119 /* 120 * New FAT inode stuff. We do the following: 121 * a) i_ino is constant and has nothing with on-disk location. 122 * b) FAT manages its own cache of directory entries. 123 * c) *This* cache is indexed by on-disk location. 124 * d) inode has an associated directory entry, all right, but 125 * it may be unhashed. 126 * e) currently entries are stored within struct inode. That should 127 * change. 128 * f) we deal with races in the following way: 129 * 1. readdir() and lookup() do FAT-dir-cache lookup. 130 * 2. rename() unhashes the F-d-c entry and rehashes it in 131 * a new place. 132 * 3. unlink() and rmdir() unhash F-d-c entry. 133 * 4. fat_write_inode() checks whether the thing is unhashed. 134 * If it is we silently return. If it isn't we do bread(), 135 * check if the location is still valid and retry if it 136 * isn't. Otherwise we do changes. 137 * 5. Spinlock is used to protect hash/unhash/location check/lookup 138 * 6. fat_clear_inode() unhashes the F-d-c entry. 139 * 7. lookup() and readdir() do igrab() if they find a F-d-c entry 140 * and consider negative result as cache miss. 141 */ 142 143 static void fat_hash_init(struct super_block *sb) 144 { 145 struct msdos_sb_info *sbi = MSDOS_SB(sb); 146 int i; 147 148 spin_lock_init(&sbi->inode_hash_lock); 149 for (i = 0; i < FAT_HASH_SIZE; i++) 150 INIT_HLIST_HEAD(&sbi->inode_hashtable[i]); 151 } 152 153 static inline unsigned long fat_hash(struct super_block *sb, loff_t i_pos) 154 { 155 unsigned long tmp = (unsigned long)i_pos | (unsigned long) sb; 156 tmp = tmp + (tmp >> FAT_HASH_BITS) + (tmp >> FAT_HASH_BITS * 2); 157 return tmp & FAT_HASH_MASK; 158 } 159 160 void fat_attach(struct inode *inode, loff_t i_pos) 161 { 162 struct super_block *sb = inode->i_sb; 163 struct msdos_sb_info *sbi = MSDOS_SB(sb); 164 165 spin_lock(&sbi->inode_hash_lock); 166 MSDOS_I(inode)->i_pos = i_pos; 167 hlist_add_head(&MSDOS_I(inode)->i_fat_hash, 168 sbi->inode_hashtable + fat_hash(sb, i_pos)); 169 spin_unlock(&sbi->inode_hash_lock); 170 } 171 172 EXPORT_SYMBOL(fat_attach); 173 174 void fat_detach(struct inode *inode) 175 { 176 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 177 spin_lock(&sbi->inode_hash_lock); 178 MSDOS_I(inode)->i_pos = 0; 179 hlist_del_init(&MSDOS_I(inode)->i_fat_hash); 180 spin_unlock(&sbi->inode_hash_lock); 181 } 182 183 EXPORT_SYMBOL(fat_detach); 184 185 struct inode *fat_iget(struct super_block *sb, loff_t i_pos) 186 { 187 struct msdos_sb_info *sbi = MSDOS_SB(sb); 188 struct hlist_head *head = sbi->inode_hashtable + fat_hash(sb, i_pos); 189 struct hlist_node *_p; 190 struct msdos_inode_info *i; 191 struct inode *inode = NULL; 192 193 spin_lock(&sbi->inode_hash_lock); 194 hlist_for_each_entry(i, _p, head, i_fat_hash) { 195 BUG_ON(i->vfs_inode.i_sb != sb); 196 if (i->i_pos != i_pos) 197 continue; 198 inode = igrab(&i->vfs_inode); 199 if (inode) 200 break; 201 } 202 spin_unlock(&sbi->inode_hash_lock); 203 return inode; 204 } 205 206 static int is_exec(unsigned char *extension) 207 { 208 unsigned char *exe_extensions = "EXECOMBAT", *walk; 209 210 for (walk = exe_extensions; *walk; walk += 3) 211 if (!strncmp(extension, walk, 3)) 212 return 1; 213 return 0; 214 } 215 216 static int fat_calc_dir_size(struct inode *inode) 217 { 218 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 219 int ret, fclus, dclus; 220 221 inode->i_size = 0; 222 if (MSDOS_I(inode)->i_start == 0) 223 return 0; 224 225 ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus); 226 if (ret < 0) 227 return ret; 228 inode->i_size = (fclus + 1) << sbi->cluster_bits; 229 230 return 0; 231 } 232 233 /* doesn't deal with root inode */ 234 static int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de) 235 { 236 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 237 int error; 238 239 MSDOS_I(inode)->i_pos = 0; 240 inode->i_uid = sbi->options.fs_uid; 241 inode->i_gid = sbi->options.fs_gid; 242 inode->i_version++; 243 inode->i_generation = get_seconds(); 244 245 if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) { 246 inode->i_generation &= ~1; 247 inode->i_mode = MSDOS_MKMODE(de->attr, 248 S_IRWXUGO & ~sbi->options.fs_dmask) | S_IFDIR; 249 inode->i_op = sbi->dir_ops; 250 inode->i_fop = &fat_dir_operations; 251 252 MSDOS_I(inode)->i_start = le16_to_cpu(de->start); 253 if (sbi->fat_bits == 32) 254 MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16); 255 256 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start; 257 error = fat_calc_dir_size(inode); 258 if (error < 0) 259 return error; 260 MSDOS_I(inode)->mmu_private = inode->i_size; 261 262 inode->i_nlink = fat_subdirs(inode); 263 } else { /* not a directory */ 264 inode->i_generation |= 1; 265 inode->i_mode = MSDOS_MKMODE(de->attr, 266 ((sbi->options.showexec && 267 !is_exec(de->ext)) 268 ? S_IRUGO|S_IWUGO : S_IRWXUGO) 269 & ~sbi->options.fs_fmask) | S_IFREG; 270 MSDOS_I(inode)->i_start = le16_to_cpu(de->start); 271 if (sbi->fat_bits == 32) 272 MSDOS_I(inode)->i_start |= (le16_to_cpu(de->starthi) << 16); 273 274 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start; 275 inode->i_size = le32_to_cpu(de->size); 276 inode->i_op = &fat_file_inode_operations; 277 inode->i_fop = &fat_file_operations; 278 inode->i_mapping->a_ops = &fat_aops; 279 MSDOS_I(inode)->mmu_private = inode->i_size; 280 } 281 if (de->attr & ATTR_SYS) { 282 if (sbi->options.sys_immutable) 283 inode->i_flags |= S_IMMUTABLE; 284 } 285 MSDOS_I(inode)->i_attrs = de->attr & ATTR_UNUSED; 286 /* this is as close to the truth as we can get ... */ 287 inode->i_blksize = sbi->cluster_size; 288 inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) 289 & ~((loff_t)sbi->cluster_size - 1)) >> 9; 290 inode->i_mtime.tv_sec = inode->i_atime.tv_sec = 291 date_dos2unix(le16_to_cpu(de->time), le16_to_cpu(de->date)); 292 inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = 0; 293 if (sbi->options.isvfat) { 294 int secs = de->ctime_cs / 100; 295 int csecs = de->ctime_cs % 100; 296 inode->i_ctime.tv_sec = 297 date_dos2unix(le16_to_cpu(de->ctime), 298 le16_to_cpu(de->cdate)) + secs; 299 inode->i_ctime.tv_nsec = csecs * 10000000; 300 } else 301 inode->i_ctime = inode->i_mtime; 302 303 return 0; 304 } 305 306 struct inode *fat_build_inode(struct super_block *sb, 307 struct msdos_dir_entry *de, loff_t i_pos) 308 { 309 struct inode *inode; 310 int err; 311 312 inode = fat_iget(sb, i_pos); 313 if (inode) 314 goto out; 315 inode = new_inode(sb); 316 if (!inode) { 317 inode = ERR_PTR(-ENOMEM); 318 goto out; 319 } 320 inode->i_ino = iunique(sb, MSDOS_ROOT_INO); 321 inode->i_version = 1; 322 err = fat_fill_inode(inode, de); 323 if (err) { 324 iput(inode); 325 inode = ERR_PTR(err); 326 goto out; 327 } 328 fat_attach(inode, i_pos); 329 insert_inode_hash(inode); 330 out: 331 return inode; 332 } 333 334 EXPORT_SYMBOL(fat_build_inode); 335 336 static void fat_delete_inode(struct inode *inode) 337 { 338 if (!is_bad_inode(inode)) { 339 inode->i_size = 0; 340 fat_truncate(inode); 341 } 342 clear_inode(inode); 343 } 344 345 static void fat_clear_inode(struct inode *inode) 346 { 347 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 348 349 if (is_bad_inode(inode)) 350 return; 351 lock_kernel(); 352 spin_lock(&sbi->inode_hash_lock); 353 fat_cache_inval_inode(inode); 354 hlist_del_init(&MSDOS_I(inode)->i_fat_hash); 355 spin_unlock(&sbi->inode_hash_lock); 356 unlock_kernel(); 357 } 358 359 static void fat_put_super(struct super_block *sb) 360 { 361 struct msdos_sb_info *sbi = MSDOS_SB(sb); 362 363 if (!(sb->s_flags & MS_RDONLY)) 364 fat_clusters_flush(sb); 365 366 if (sbi->nls_disk) { 367 unload_nls(sbi->nls_disk); 368 sbi->nls_disk = NULL; 369 sbi->options.codepage = fat_default_codepage; 370 } 371 if (sbi->nls_io) { 372 unload_nls(sbi->nls_io); 373 sbi->nls_io = NULL; 374 } 375 if (sbi->options.iocharset != fat_default_iocharset) { 376 kfree(sbi->options.iocharset); 377 sbi->options.iocharset = fat_default_iocharset; 378 } 379 380 sb->s_fs_info = NULL; 381 kfree(sbi); 382 } 383 384 static kmem_cache_t *fat_inode_cachep; 385 386 static struct inode *fat_alloc_inode(struct super_block *sb) 387 { 388 struct msdos_inode_info *ei; 389 ei = kmem_cache_alloc(fat_inode_cachep, SLAB_KERNEL); 390 if (!ei) 391 return NULL; 392 return &ei->vfs_inode; 393 } 394 395 static void fat_destroy_inode(struct inode *inode) 396 { 397 kmem_cache_free(fat_inode_cachep, MSDOS_I(inode)); 398 } 399 400 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) 401 { 402 struct msdos_inode_info *ei = (struct msdos_inode_info *)foo; 403 404 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == 405 SLAB_CTOR_CONSTRUCTOR) { 406 spin_lock_init(&ei->cache_lru_lock); 407 ei->nr_caches = 0; 408 ei->cache_valid_id = FAT_CACHE_VALID + 1; 409 INIT_LIST_HEAD(&ei->cache_lru); 410 INIT_HLIST_NODE(&ei->i_fat_hash); 411 inode_init_once(&ei->vfs_inode); 412 } 413 } 414 415 static int __init fat_init_inodecache(void) 416 { 417 fat_inode_cachep = kmem_cache_create("fat_inode_cache", 418 sizeof(struct msdos_inode_info), 419 0, SLAB_RECLAIM_ACCOUNT, 420 init_once, NULL); 421 if (fat_inode_cachep == NULL) 422 return -ENOMEM; 423 return 0; 424 } 425 426 static void __exit fat_destroy_inodecache(void) 427 { 428 if (kmem_cache_destroy(fat_inode_cachep)) 429 printk(KERN_INFO "fat_inode_cache: not all structures were freed\n"); 430 } 431 432 static int fat_remount(struct super_block *sb, int *flags, char *data) 433 { 434 struct msdos_sb_info *sbi = MSDOS_SB(sb); 435 *flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME); 436 return 0; 437 } 438 439 static int fat_statfs(struct super_block *sb, struct kstatfs *buf) 440 { 441 struct msdos_sb_info *sbi = MSDOS_SB(sb); 442 443 /* If the count of free cluster is still unknown, counts it here. */ 444 if (sbi->free_clusters == -1) { 445 int err = fat_count_free_clusters(sb); 446 if (err) 447 return err; 448 } 449 450 buf->f_type = sb->s_magic; 451 buf->f_bsize = sbi->cluster_size; 452 buf->f_blocks = sbi->max_cluster - FAT_START_ENT; 453 buf->f_bfree = sbi->free_clusters; 454 buf->f_bavail = sbi->free_clusters; 455 buf->f_namelen = sbi->options.isvfat ? 260 : 12; 456 457 return 0; 458 } 459 460 static int fat_write_inode(struct inode *inode, int wait) 461 { 462 struct super_block *sb = inode->i_sb; 463 struct msdos_sb_info *sbi = MSDOS_SB(sb); 464 struct buffer_head *bh; 465 struct msdos_dir_entry *raw_entry; 466 loff_t i_pos; 467 int err = 0; 468 469 retry: 470 i_pos = MSDOS_I(inode)->i_pos; 471 if (inode->i_ino == MSDOS_ROOT_INO || !i_pos) 472 return 0; 473 474 lock_kernel(); 475 bh = sb_bread(sb, i_pos >> sbi->dir_per_block_bits); 476 if (!bh) { 477 printk(KERN_ERR "FAT: unable to read inode block " 478 "for updating (i_pos %lld)\n", i_pos); 479 err = -EIO; 480 goto out; 481 } 482 spin_lock(&sbi->inode_hash_lock); 483 if (i_pos != MSDOS_I(inode)->i_pos) { 484 spin_unlock(&sbi->inode_hash_lock); 485 brelse(bh); 486 unlock_kernel(); 487 goto retry; 488 } 489 490 raw_entry = &((struct msdos_dir_entry *) (bh->b_data)) 491 [i_pos & (sbi->dir_per_block - 1)]; 492 if (S_ISDIR(inode->i_mode)) 493 raw_entry->size = 0; 494 else 495 raw_entry->size = cpu_to_le32(inode->i_size); 496 raw_entry->attr = fat_attr(inode); 497 raw_entry->start = cpu_to_le16(MSDOS_I(inode)->i_logstart); 498 raw_entry->starthi = cpu_to_le16(MSDOS_I(inode)->i_logstart >> 16); 499 fat_date_unix2dos(inode->i_mtime.tv_sec, &raw_entry->time, &raw_entry->date); 500 if (sbi->options.isvfat) { 501 fat_date_unix2dos(inode->i_ctime.tv_sec,&raw_entry->ctime,&raw_entry->cdate); 502 raw_entry->ctime_cs = (inode->i_ctime.tv_sec & 1) * 100 + 503 inode->i_ctime.tv_nsec / 10000000; 504 } 505 spin_unlock(&sbi->inode_hash_lock); 506 mark_buffer_dirty(bh); 507 if (wait) 508 err = sync_dirty_buffer(bh); 509 brelse(bh); 510 out: 511 unlock_kernel(); 512 return err; 513 } 514 515 int fat_sync_inode(struct inode *inode) 516 { 517 return fat_write_inode(inode, 1); 518 } 519 520 EXPORT_SYMBOL(fat_sync_inode); 521 522 static int fat_show_options(struct seq_file *m, struct vfsmount *mnt); 523 static struct super_operations fat_sops = { 524 .alloc_inode = fat_alloc_inode, 525 .destroy_inode = fat_destroy_inode, 526 .write_inode = fat_write_inode, 527 .delete_inode = fat_delete_inode, 528 .put_super = fat_put_super, 529 .statfs = fat_statfs, 530 .clear_inode = fat_clear_inode, 531 .remount_fs = fat_remount, 532 533 .read_inode = make_bad_inode, 534 535 .show_options = fat_show_options, 536 }; 537 538 /* 539 * a FAT file handle with fhtype 3 is 540 * 0/ i_ino - for fast, reliable lookup if still in the cache 541 * 1/ i_generation - to see if i_ino is still valid 542 * bit 0 == 0 iff directory 543 * 2/ i_pos(8-39) - if ino has changed, but still in cache 544 * 3/ i_pos(4-7)|i_logstart - to semi-verify inode found at i_pos 545 * 4/ i_pos(0-3)|parent->i_logstart - maybe used to hunt for the file on disc 546 * 547 * Hack for NFSv2: Maximum FAT entry number is 28bits and maximum 548 * i_pos is 40bits (blocknr(32) + dir offset(8)), so two 4bits 549 * of i_logstart is used to store the directory entry offset. 550 */ 551 552 static struct dentry * 553 fat_decode_fh(struct super_block *sb, __u32 *fh, int len, int fhtype, 554 int (*acceptable)(void *context, struct dentry *de), 555 void *context) 556 { 557 if (fhtype != 3) 558 return ERR_PTR(-ESTALE); 559 if (len < 5) 560 return ERR_PTR(-ESTALE); 561 562 return sb->s_export_op->find_exported_dentry(sb, fh, NULL, acceptable, context); 563 } 564 565 static struct dentry *fat_get_dentry(struct super_block *sb, void *inump) 566 { 567 struct inode *inode = NULL; 568 struct dentry *result; 569 __u32 *fh = inump; 570 571 inode = iget(sb, fh[0]); 572 if (!inode || is_bad_inode(inode) || inode->i_generation != fh[1]) { 573 if (inode) 574 iput(inode); 575 inode = NULL; 576 } 577 if (!inode) { 578 loff_t i_pos; 579 int i_logstart = fh[3] & 0x0fffffff; 580 581 i_pos = (loff_t)fh[2] << 8; 582 i_pos |= ((fh[3] >> 24) & 0xf0) | (fh[4] >> 28); 583 584 /* try 2 - see if i_pos is in F-d-c 585 * require i_logstart to be the same 586 * Will fail if you truncate and then re-write 587 */ 588 589 inode = fat_iget(sb, i_pos); 590 if (inode && MSDOS_I(inode)->i_logstart != i_logstart) { 591 iput(inode); 592 inode = NULL; 593 } 594 } 595 if (!inode) { 596 /* For now, do nothing 597 * What we could do is: 598 * follow the file starting at fh[4], and record 599 * the ".." entry, and the name of the fh[2] entry. 600 * The follow the ".." file finding the next step up. 601 * This way we build a path to the root of 602 * the tree. If this works, we lookup the path and so 603 * get this inode into the cache. 604 * Finally try the fat_iget lookup again 605 * If that fails, then weare totally out of luck 606 * But all that is for another day 607 */ 608 } 609 if (!inode) 610 return ERR_PTR(-ESTALE); 611 612 613 /* now to find a dentry. 614 * If possible, get a well-connected one 615 */ 616 result = d_alloc_anon(inode); 617 if (result == NULL) { 618 iput(inode); 619 return ERR_PTR(-ENOMEM); 620 } 621 result->d_op = sb->s_root->d_op; 622 return result; 623 } 624 625 static int 626 fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable) 627 { 628 int len = *lenp; 629 struct inode *inode = de->d_inode; 630 u32 ipos_h, ipos_m, ipos_l; 631 632 if (len < 5) 633 return 255; /* no room */ 634 635 ipos_h = MSDOS_I(inode)->i_pos >> 8; 636 ipos_m = (MSDOS_I(inode)->i_pos & 0xf0) << 24; 637 ipos_l = (MSDOS_I(inode)->i_pos & 0x0f) << 28; 638 *lenp = 5; 639 fh[0] = inode->i_ino; 640 fh[1] = inode->i_generation; 641 fh[2] = ipos_h; 642 fh[3] = ipos_m | MSDOS_I(inode)->i_logstart; 643 spin_lock(&de->d_lock); 644 fh[4] = ipos_l | MSDOS_I(de->d_parent->d_inode)->i_logstart; 645 spin_unlock(&de->d_lock); 646 return 3; 647 } 648 649 static struct dentry *fat_get_parent(struct dentry *child) 650 { 651 struct buffer_head *bh; 652 struct msdos_dir_entry *de; 653 loff_t i_pos; 654 struct dentry *parent; 655 struct inode *inode; 656 int err; 657 658 lock_kernel(); 659 660 err = fat_get_dotdot_entry(child->d_inode, &bh, &de, &i_pos); 661 if (err) { 662 parent = ERR_PTR(err); 663 goto out; 664 } 665 inode = fat_build_inode(child->d_sb, de, i_pos); 666 brelse(bh); 667 if (IS_ERR(inode)) { 668 parent = ERR_PTR(PTR_ERR(inode)); 669 goto out; 670 } 671 parent = d_alloc_anon(inode); 672 if (!parent) { 673 iput(inode); 674 parent = ERR_PTR(-ENOMEM); 675 } 676 out: 677 unlock_kernel(); 678 679 return parent; 680 } 681 682 static struct export_operations fat_export_ops = { 683 .decode_fh = fat_decode_fh, 684 .encode_fh = fat_encode_fh, 685 .get_dentry = fat_get_dentry, 686 .get_parent = fat_get_parent, 687 }; 688 689 static int fat_show_options(struct seq_file *m, struct vfsmount *mnt) 690 { 691 struct msdos_sb_info *sbi = MSDOS_SB(mnt->mnt_sb); 692 struct fat_mount_options *opts = &sbi->options; 693 int isvfat = opts->isvfat; 694 695 if (opts->fs_uid != 0) 696 seq_printf(m, ",uid=%u", opts->fs_uid); 697 if (opts->fs_gid != 0) 698 seq_printf(m, ",gid=%u", opts->fs_gid); 699 seq_printf(m, ",fmask=%04o", opts->fs_fmask); 700 seq_printf(m, ",dmask=%04o", opts->fs_dmask); 701 if (sbi->nls_disk) 702 seq_printf(m, ",codepage=%s", sbi->nls_disk->charset); 703 if (isvfat) { 704 if (sbi->nls_io) 705 seq_printf(m, ",iocharset=%s", sbi->nls_io->charset); 706 707 switch (opts->shortname) { 708 case VFAT_SFN_DISPLAY_WIN95 | VFAT_SFN_CREATE_WIN95: 709 seq_puts(m, ",shortname=win95"); 710 break; 711 case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WINNT: 712 seq_puts(m, ",shortname=winnt"); 713 break; 714 case VFAT_SFN_DISPLAY_WINNT | VFAT_SFN_CREATE_WIN95: 715 seq_puts(m, ",shortname=mixed"); 716 break; 717 case VFAT_SFN_DISPLAY_LOWER | VFAT_SFN_CREATE_WIN95: 718 /* seq_puts(m, ",shortname=lower"); */ 719 break; 720 default: 721 seq_puts(m, ",shortname=unknown"); 722 break; 723 } 724 } 725 if (opts->name_check != 'n') 726 seq_printf(m, ",check=%c", opts->name_check); 727 if (opts->quiet) 728 seq_puts(m, ",quiet"); 729 if (opts->showexec) 730 seq_puts(m, ",showexec"); 731 if (opts->sys_immutable) 732 seq_puts(m, ",sys_immutable"); 733 if (!isvfat) { 734 if (opts->dotsOK) 735 seq_puts(m, ",dotsOK=yes"); 736 if (opts->nocase) 737 seq_puts(m, ",nocase"); 738 } else { 739 if (opts->utf8) 740 seq_puts(m, ",utf8"); 741 if (opts->unicode_xlate) 742 seq_puts(m, ",uni_xlate"); 743 if (!opts->numtail) 744 seq_puts(m, ",nonumtail"); 745 } 746 747 return 0; 748 } 749 750 enum { 751 Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid, 752 Opt_umask, Opt_dmask, Opt_fmask, Opt_codepage, Opt_nocase, 753 Opt_quiet, Opt_showexec, Opt_debug, Opt_immutable, 754 Opt_dots, Opt_nodots, 755 Opt_charset, Opt_shortname_lower, Opt_shortname_win95, 756 Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes, 757 Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes, 758 Opt_obsolate, Opt_err, 759 }; 760 761 static match_table_t fat_tokens = { 762 {Opt_check_r, "check=relaxed"}, 763 {Opt_check_s, "check=strict"}, 764 {Opt_check_n, "check=normal"}, 765 {Opt_check_r, "check=r"}, 766 {Opt_check_s, "check=s"}, 767 {Opt_check_n, "check=n"}, 768 {Opt_uid, "uid=%u"}, 769 {Opt_gid, "gid=%u"}, 770 {Opt_umask, "umask=%o"}, 771 {Opt_dmask, "dmask=%o"}, 772 {Opt_fmask, "fmask=%o"}, 773 {Opt_codepage, "codepage=%u"}, 774 {Opt_nocase, "nocase"}, 775 {Opt_quiet, "quiet"}, 776 {Opt_showexec, "showexec"}, 777 {Opt_debug, "debug"}, 778 {Opt_immutable, "sys_immutable"}, 779 {Opt_obsolate, "conv=binary"}, 780 {Opt_obsolate, "conv=text"}, 781 {Opt_obsolate, "conv=auto"}, 782 {Opt_obsolate, "conv=b"}, 783 {Opt_obsolate, "conv=t"}, 784 {Opt_obsolate, "conv=a"}, 785 {Opt_obsolate, "fat=%u"}, 786 {Opt_obsolate, "blocksize=%u"}, 787 {Opt_obsolate, "cvf_format=%20s"}, 788 {Opt_obsolate, "cvf_options=%100s"}, 789 {Opt_obsolate, "posix"}, 790 {Opt_err, NULL} 791 }; 792 static match_table_t msdos_tokens = { 793 {Opt_nodots, "nodots"}, 794 {Opt_nodots, "dotsOK=no"}, 795 {Opt_dots, "dots"}, 796 {Opt_dots, "dotsOK=yes"}, 797 {Opt_err, NULL} 798 }; 799 static match_table_t vfat_tokens = { 800 {Opt_charset, "iocharset=%s"}, 801 {Opt_shortname_lower, "shortname=lower"}, 802 {Opt_shortname_win95, "shortname=win95"}, 803 {Opt_shortname_winnt, "shortname=winnt"}, 804 {Opt_shortname_mixed, "shortname=mixed"}, 805 {Opt_utf8_no, "utf8=0"}, /* 0 or no or false */ 806 {Opt_utf8_no, "utf8=no"}, 807 {Opt_utf8_no, "utf8=false"}, 808 {Opt_utf8_yes, "utf8=1"}, /* empty or 1 or yes or true */ 809 {Opt_utf8_yes, "utf8=yes"}, 810 {Opt_utf8_yes, "utf8=true"}, 811 {Opt_utf8_yes, "utf8"}, 812 {Opt_uni_xl_no, "uni_xlate=0"}, /* 0 or no or false */ 813 {Opt_uni_xl_no, "uni_xlate=no"}, 814 {Opt_uni_xl_no, "uni_xlate=false"}, 815 {Opt_uni_xl_yes, "uni_xlate=1"}, /* empty or 1 or yes or true */ 816 {Opt_uni_xl_yes, "uni_xlate=yes"}, 817 {Opt_uni_xl_yes, "uni_xlate=true"}, 818 {Opt_uni_xl_yes, "uni_xlate"}, 819 {Opt_nonumtail_no, "nonumtail=0"}, /* 0 or no or false */ 820 {Opt_nonumtail_no, "nonumtail=no"}, 821 {Opt_nonumtail_no, "nonumtail=false"}, 822 {Opt_nonumtail_yes, "nonumtail=1"}, /* empty or 1 or yes or true */ 823 {Opt_nonumtail_yes, "nonumtail=yes"}, 824 {Opt_nonumtail_yes, "nonumtail=true"}, 825 {Opt_nonumtail_yes, "nonumtail"}, 826 {Opt_err, NULL} 827 }; 828 829 static int parse_options(char *options, int is_vfat, int *debug, 830 struct fat_mount_options *opts) 831 { 832 char *p; 833 substring_t args[MAX_OPT_ARGS]; 834 int option; 835 char *iocharset; 836 837 opts->isvfat = is_vfat; 838 839 opts->fs_uid = current->uid; 840 opts->fs_gid = current->gid; 841 opts->fs_fmask = opts->fs_dmask = current->fs->umask; 842 opts->codepage = fat_default_codepage; 843 opts->iocharset = fat_default_iocharset; 844 if (is_vfat) 845 opts->shortname = VFAT_SFN_DISPLAY_LOWER|VFAT_SFN_CREATE_WIN95; 846 else 847 opts->shortname = 0; 848 opts->name_check = 'n'; 849 opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK = 0; 850 opts->utf8 = opts->unicode_xlate = 0; 851 opts->numtail = 1; 852 opts->nocase = 0; 853 *debug = 0; 854 855 if (!options) 856 return 0; 857 858 while ((p = strsep(&options, ",")) != NULL) { 859 int token; 860 if (!*p) 861 continue; 862 863 token = match_token(p, fat_tokens, args); 864 if (token == Opt_err) { 865 if (is_vfat) 866 token = match_token(p, vfat_tokens, args); 867 else 868 token = match_token(p, msdos_tokens, args); 869 } 870 switch (token) { 871 case Opt_check_s: 872 opts->name_check = 's'; 873 break; 874 case Opt_check_r: 875 opts->name_check = 'r'; 876 break; 877 case Opt_check_n: 878 opts->name_check = 'n'; 879 break; 880 case Opt_nocase: 881 if (!is_vfat) 882 opts->nocase = 1; 883 else { 884 /* for backward compatibility */ 885 opts->shortname = VFAT_SFN_DISPLAY_WIN95 886 | VFAT_SFN_CREATE_WIN95; 887 } 888 break; 889 case Opt_quiet: 890 opts->quiet = 1; 891 break; 892 case Opt_showexec: 893 opts->showexec = 1; 894 break; 895 case Opt_debug: 896 *debug = 1; 897 break; 898 case Opt_immutable: 899 opts->sys_immutable = 1; 900 break; 901 case Opt_uid: 902 if (match_int(&args[0], &option)) 903 return 0; 904 opts->fs_uid = option; 905 break; 906 case Opt_gid: 907 if (match_int(&args[0], &option)) 908 return 0; 909 opts->fs_gid = option; 910 break; 911 case Opt_umask: 912 if (match_octal(&args[0], &option)) 913 return 0; 914 opts->fs_fmask = opts->fs_dmask = option; 915 break; 916 case Opt_dmask: 917 if (match_octal(&args[0], &option)) 918 return 0; 919 opts->fs_dmask = option; 920 break; 921 case Opt_fmask: 922 if (match_octal(&args[0], &option)) 923 return 0; 924 opts->fs_fmask = option; 925 break; 926 case Opt_codepage: 927 if (match_int(&args[0], &option)) 928 return 0; 929 opts->codepage = option; 930 break; 931 932 /* msdos specific */ 933 case Opt_dots: 934 opts->dotsOK = 1; 935 break; 936 case Opt_nodots: 937 opts->dotsOK = 0; 938 break; 939 940 /* vfat specific */ 941 case Opt_charset: 942 if (opts->iocharset != fat_default_iocharset) 943 kfree(opts->iocharset); 944 iocharset = match_strdup(&args[0]); 945 if (!iocharset) 946 return -ENOMEM; 947 opts->iocharset = iocharset; 948 break; 949 case Opt_shortname_lower: 950 opts->shortname = VFAT_SFN_DISPLAY_LOWER 951 | VFAT_SFN_CREATE_WIN95; 952 break; 953 case Opt_shortname_win95: 954 opts->shortname = VFAT_SFN_DISPLAY_WIN95 955 | VFAT_SFN_CREATE_WIN95; 956 break; 957 case Opt_shortname_winnt: 958 opts->shortname = VFAT_SFN_DISPLAY_WINNT 959 | VFAT_SFN_CREATE_WINNT; 960 break; 961 case Opt_shortname_mixed: 962 opts->shortname = VFAT_SFN_DISPLAY_WINNT 963 | VFAT_SFN_CREATE_WIN95; 964 break; 965 case Opt_utf8_no: /* 0 or no or false */ 966 opts->utf8 = 0; 967 break; 968 case Opt_utf8_yes: /* empty or 1 or yes or true */ 969 opts->utf8 = 1; 970 break; 971 case Opt_uni_xl_no: /* 0 or no or false */ 972 opts->unicode_xlate = 0; 973 break; 974 case Opt_uni_xl_yes: /* empty or 1 or yes or true */ 975 opts->unicode_xlate = 1; 976 break; 977 case Opt_nonumtail_no: /* 0 or no or false */ 978 opts->numtail = 1; /* negated option */ 979 break; 980 case Opt_nonumtail_yes: /* empty or 1 or yes or true */ 981 opts->numtail = 0; /* negated option */ 982 break; 983 984 /* obsolete mount options */ 985 case Opt_obsolate: 986 printk(KERN_INFO "FAT: \"%s\" option is obsolete, " 987 "not supported now\n", p); 988 break; 989 /* unknown option */ 990 default: 991 printk(KERN_ERR "FAT: Unrecognized mount option \"%s\" " 992 "or missing value\n", p); 993 return -EINVAL; 994 } 995 } 996 /* UTF8 doesn't provide FAT semantics */ 997 if (!strcmp(opts->iocharset, "utf8")) { 998 printk(KERN_ERR "FAT: utf8 is not a recommended IO charset" 999 " for FAT filesystems, filesystem will be case sensitive!\n"); 1000 } 1001 1002 if (opts->unicode_xlate) 1003 opts->utf8 = 0; 1004 1005 return 0; 1006 } 1007 1008 static int fat_read_root(struct inode *inode) 1009 { 1010 struct super_block *sb = inode->i_sb; 1011 struct msdos_sb_info *sbi = MSDOS_SB(sb); 1012 int error; 1013 1014 MSDOS_I(inode)->i_pos = 0; 1015 inode->i_uid = sbi->options.fs_uid; 1016 inode->i_gid = sbi->options.fs_gid; 1017 inode->i_version++; 1018 inode->i_generation = 0; 1019 inode->i_mode = (S_IRWXUGO & ~sbi->options.fs_dmask) | S_IFDIR; 1020 inode->i_op = sbi->dir_ops; 1021 inode->i_fop = &fat_dir_operations; 1022 if (sbi->fat_bits == 32) { 1023 MSDOS_I(inode)->i_start = sbi->root_cluster; 1024 error = fat_calc_dir_size(inode); 1025 if (error < 0) 1026 return error; 1027 } else { 1028 MSDOS_I(inode)->i_start = 0; 1029 inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry); 1030 } 1031 inode->i_blksize = sbi->cluster_size; 1032 inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) 1033 & ~((loff_t)sbi->cluster_size - 1)) >> 9; 1034 MSDOS_I(inode)->i_logstart = 0; 1035 MSDOS_I(inode)->mmu_private = inode->i_size; 1036 1037 MSDOS_I(inode)->i_attrs = ATTR_NONE; 1038 inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = 0; 1039 inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = 0; 1040 inode->i_nlink = fat_subdirs(inode)+2; 1041 1042 return 0; 1043 } 1044 1045 /* 1046 * Read the super block of an MS-DOS FS. 1047 */ 1048 int fat_fill_super(struct super_block *sb, void *data, int silent, 1049 struct inode_operations *fs_dir_inode_ops, int isvfat) 1050 { 1051 struct inode *root_inode = NULL; 1052 struct buffer_head *bh; 1053 struct fat_boot_sector *b; 1054 struct msdos_sb_info *sbi; 1055 u16 logical_sector_size; 1056 u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors; 1057 int debug; 1058 unsigned int media; 1059 long error; 1060 char buf[50]; 1061 1062 sbi = kmalloc(sizeof(struct msdos_sb_info), GFP_KERNEL); 1063 if (!sbi) 1064 return -ENOMEM; 1065 sb->s_fs_info = sbi; 1066 memset(sbi, 0, sizeof(struct msdos_sb_info)); 1067 1068 sb->s_flags |= MS_NODIRATIME; 1069 sb->s_magic = MSDOS_SUPER_MAGIC; 1070 sb->s_op = &fat_sops; 1071 sb->s_export_op = &fat_export_ops; 1072 sbi->dir_ops = fs_dir_inode_ops; 1073 1074 error = parse_options(data, isvfat, &debug, &sbi->options); 1075 if (error) 1076 goto out_fail; 1077 1078 error = -EIO; 1079 sb_min_blocksize(sb, 512); 1080 bh = sb_bread(sb, 0); 1081 if (bh == NULL) { 1082 printk(KERN_ERR "FAT: unable to read boot sector\n"); 1083 goto out_fail; 1084 } 1085 1086 b = (struct fat_boot_sector *) bh->b_data; 1087 if (!b->reserved) { 1088 if (!silent) 1089 printk(KERN_ERR "FAT: bogus number of reserved sectors\n"); 1090 brelse(bh); 1091 goto out_invalid; 1092 } 1093 if (!b->fats) { 1094 if (!silent) 1095 printk(KERN_ERR "FAT: bogus number of FAT structure\n"); 1096 brelse(bh); 1097 goto out_invalid; 1098 } 1099 1100 /* 1101 * Earlier we checked here that b->secs_track and b->head are nonzero, 1102 * but it turns out valid FAT filesystems can have zero there. 1103 */ 1104 1105 media = b->media; 1106 if (!FAT_VALID_MEDIA(media)) { 1107 if (!silent) 1108 printk(KERN_ERR "FAT: invalid media value (0x%02x)\n", 1109 media); 1110 brelse(bh); 1111 goto out_invalid; 1112 } 1113 logical_sector_size = 1114 le16_to_cpu(get_unaligned((__le16 *)&b->sector_size)); 1115 if (!logical_sector_size 1116 || (logical_sector_size & (logical_sector_size - 1)) 1117 || (logical_sector_size < 512) 1118 || (PAGE_CACHE_SIZE < logical_sector_size)) { 1119 if (!silent) 1120 printk(KERN_ERR "FAT: bogus logical sector size %u\n", 1121 logical_sector_size); 1122 brelse(bh); 1123 goto out_invalid; 1124 } 1125 sbi->sec_per_clus = b->sec_per_clus; 1126 if (!sbi->sec_per_clus 1127 || (sbi->sec_per_clus & (sbi->sec_per_clus - 1))) { 1128 if (!silent) 1129 printk(KERN_ERR "FAT: bogus sectors per cluster %u\n", 1130 sbi->sec_per_clus); 1131 brelse(bh); 1132 goto out_invalid; 1133 } 1134 1135 if (logical_sector_size < sb->s_blocksize) { 1136 printk(KERN_ERR "FAT: logical sector size too small for device" 1137 " (logical sector size = %u)\n", logical_sector_size); 1138 brelse(bh); 1139 goto out_fail; 1140 } 1141 if (logical_sector_size > sb->s_blocksize) { 1142 brelse(bh); 1143 1144 if (!sb_set_blocksize(sb, logical_sector_size)) { 1145 printk(KERN_ERR "FAT: unable to set blocksize %u\n", 1146 logical_sector_size); 1147 goto out_fail; 1148 } 1149 bh = sb_bread(sb, 0); 1150 if (bh == NULL) { 1151 printk(KERN_ERR "FAT: unable to read boot sector" 1152 " (logical sector size = %lu)\n", 1153 sb->s_blocksize); 1154 goto out_fail; 1155 } 1156 b = (struct fat_boot_sector *) bh->b_data; 1157 } 1158 1159 sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus; 1160 sbi->cluster_bits = ffs(sbi->cluster_size) - 1; 1161 sbi->fats = b->fats; 1162 sbi->fat_bits = 0; /* Don't know yet */ 1163 sbi->fat_start = le16_to_cpu(b->reserved); 1164 sbi->fat_length = le16_to_cpu(b->fat_length); 1165 sbi->root_cluster = 0; 1166 sbi->free_clusters = -1; /* Don't know yet */ 1167 sbi->prev_free = FAT_START_ENT; 1168 1169 if (!sbi->fat_length && b->fat32_length) { 1170 struct fat_boot_fsinfo *fsinfo; 1171 struct buffer_head *fsinfo_bh; 1172 1173 /* Must be FAT32 */ 1174 sbi->fat_bits = 32; 1175 sbi->fat_length = le32_to_cpu(b->fat32_length); 1176 sbi->root_cluster = le32_to_cpu(b->root_cluster); 1177 1178 sb->s_maxbytes = 0xffffffff; 1179 1180 /* MC - if info_sector is 0, don't multiply by 0 */ 1181 sbi->fsinfo_sector = le16_to_cpu(b->info_sector); 1182 if (sbi->fsinfo_sector == 0) 1183 sbi->fsinfo_sector = 1; 1184 1185 fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector); 1186 if (fsinfo_bh == NULL) { 1187 printk(KERN_ERR "FAT: bread failed, FSINFO block" 1188 " (sector = %lu)\n", sbi->fsinfo_sector); 1189 brelse(bh); 1190 goto out_fail; 1191 } 1192 1193 fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data; 1194 if (!IS_FSINFO(fsinfo)) { 1195 printk(KERN_WARNING 1196 "FAT: Did not find valid FSINFO signature.\n" 1197 " Found signature1 0x%08x signature2 0x%08x" 1198 " (sector = %lu)\n", 1199 le32_to_cpu(fsinfo->signature1), 1200 le32_to_cpu(fsinfo->signature2), 1201 sbi->fsinfo_sector); 1202 } else { 1203 sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters); 1204 sbi->prev_free = le32_to_cpu(fsinfo->next_cluster); 1205 } 1206 1207 brelse(fsinfo_bh); 1208 } 1209 1210 sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry); 1211 sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1; 1212 1213 sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length; 1214 sbi->dir_entries = 1215 le16_to_cpu(get_unaligned((__le16 *)&b->dir_entries)); 1216 if (sbi->dir_entries & (sbi->dir_per_block - 1)) { 1217 if (!silent) 1218 printk(KERN_ERR "FAT: bogus directroy-entries per block" 1219 " (%u)\n", sbi->dir_entries); 1220 brelse(bh); 1221 goto out_invalid; 1222 } 1223 1224 rootdir_sectors = sbi->dir_entries 1225 * sizeof(struct msdos_dir_entry) / sb->s_blocksize; 1226 sbi->data_start = sbi->dir_start + rootdir_sectors; 1227 total_sectors = le16_to_cpu(get_unaligned((__le16 *)&b->sectors)); 1228 if (total_sectors == 0) 1229 total_sectors = le32_to_cpu(b->total_sect); 1230 1231 total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus; 1232 1233 if (sbi->fat_bits != 32) 1234 sbi->fat_bits = (total_clusters > MAX_FAT12) ? 16 : 12; 1235 1236 /* check that FAT table does not overflow */ 1237 fat_clusters = sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits; 1238 total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT); 1239 if (total_clusters > MAX_FAT(sb)) { 1240 if (!silent) 1241 printk(KERN_ERR "FAT: count of clusters too big (%u)\n", 1242 total_clusters); 1243 brelse(bh); 1244 goto out_invalid; 1245 } 1246 1247 sbi->max_cluster = total_clusters + FAT_START_ENT; 1248 /* check the free_clusters, it's not necessarily correct */ 1249 if (sbi->free_clusters != -1 && sbi->free_clusters > total_clusters) 1250 sbi->free_clusters = -1; 1251 /* check the prev_free, it's not necessarily correct */ 1252 sbi->prev_free %= sbi->max_cluster; 1253 if (sbi->prev_free < FAT_START_ENT) 1254 sbi->prev_free = FAT_START_ENT; 1255 1256 brelse(bh); 1257 1258 /* set up enough so that it can read an inode */ 1259 fat_hash_init(sb); 1260 fat_ent_access_init(sb); 1261 1262 /* 1263 * The low byte of FAT's first entry must have same value with 1264 * media-field. But in real world, too many devices is 1265 * writing wrong value. So, removed that validity check. 1266 * 1267 * if (FAT_FIRST_ENT(sb, media) != first) 1268 */ 1269 1270 error = -EINVAL; 1271 sprintf(buf, "cp%d", sbi->options.codepage); 1272 sbi->nls_disk = load_nls(buf); 1273 if (!sbi->nls_disk) { 1274 printk(KERN_ERR "FAT: codepage %s not found\n", buf); 1275 goto out_fail; 1276 } 1277 1278 /* FIXME: utf8 is using iocharset for upper/lower conversion */ 1279 if (sbi->options.isvfat) { 1280 sbi->nls_io = load_nls(sbi->options.iocharset); 1281 if (!sbi->nls_io) { 1282 printk(KERN_ERR "FAT: IO charset %s not found\n", 1283 sbi->options.iocharset); 1284 goto out_fail; 1285 } 1286 } 1287 1288 error = -ENOMEM; 1289 root_inode = new_inode(sb); 1290 if (!root_inode) 1291 goto out_fail; 1292 root_inode->i_ino = MSDOS_ROOT_INO; 1293 root_inode->i_version = 1; 1294 error = fat_read_root(root_inode); 1295 if (error < 0) 1296 goto out_fail; 1297 error = -ENOMEM; 1298 insert_inode_hash(root_inode); 1299 sb->s_root = d_alloc_root(root_inode); 1300 if (!sb->s_root) { 1301 printk(KERN_ERR "FAT: get root inode failed\n"); 1302 goto out_fail; 1303 } 1304 1305 return 0; 1306 1307 out_invalid: 1308 error = -EINVAL; 1309 if (!silent) 1310 printk(KERN_INFO "VFS: Can't find a valid FAT filesystem" 1311 " on dev %s.\n", sb->s_id); 1312 1313 out_fail: 1314 if (root_inode) 1315 iput(root_inode); 1316 if (sbi->nls_io) 1317 unload_nls(sbi->nls_io); 1318 if (sbi->nls_disk) 1319 unload_nls(sbi->nls_disk); 1320 if (sbi->options.iocharset != fat_default_iocharset) 1321 kfree(sbi->options.iocharset); 1322 sb->s_fs_info = NULL; 1323 kfree(sbi); 1324 return error; 1325 } 1326 1327 EXPORT_SYMBOL(fat_fill_super); 1328 1329 int __init fat_cache_init(void); 1330 void __exit fat_cache_destroy(void); 1331 1332 static int __init init_fat_fs(void) 1333 { 1334 int ret; 1335 1336 ret = fat_cache_init(); 1337 if (ret < 0) 1338 return ret; 1339 return fat_init_inodecache(); 1340 } 1341 1342 static void __exit exit_fat_fs(void) 1343 { 1344 fat_cache_destroy(); 1345 fat_destroy_inodecache(); 1346 } 1347 1348 module_init(init_fat_fs) 1349 module_exit(exit_fat_fs) 1350 1351 MODULE_LICENSE("GPL"); 1352