1 /* 2 * Optimized MPEG FS - inode and super operations. 3 * Copyright (C) 2006 Bob Copeland <me@bobcopeland.com> 4 * Released under GPL v2. 5 */ 6 #include <linux/module.h> 7 #include <linux/sched.h> 8 #include <linux/slab.h> 9 #include <linux/fs.h> 10 #include <linux/vfs.h> 11 #include <linux/cred.h> 12 #include <linux/parser.h> 13 #include <linux/buffer_head.h> 14 #include <linux/vmalloc.h> 15 #include <linux/writeback.h> 16 #include <linux/crc-itu-t.h> 17 #include "omfs.h" 18 19 MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>"); 20 MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux"); 21 MODULE_LICENSE("GPL"); 22 23 struct buffer_head *omfs_bread(struct super_block *sb, sector_t block) 24 { 25 struct omfs_sb_info *sbi = OMFS_SB(sb); 26 if (block >= sbi->s_num_blocks) 27 return NULL; 28 29 return sb_bread(sb, clus_to_blk(sbi, block)); 30 } 31 32 struct inode *omfs_new_inode(struct inode *dir, umode_t mode) 33 { 34 struct inode *inode; 35 u64 new_block; 36 int err; 37 int len; 38 struct omfs_sb_info *sbi = OMFS_SB(dir->i_sb); 39 40 inode = new_inode(dir->i_sb); 41 if (!inode) 42 return ERR_PTR(-ENOMEM); 43 44 err = omfs_allocate_range(dir->i_sb, sbi->s_mirrors, sbi->s_mirrors, 45 &new_block, &len); 46 if (err) 47 goto fail; 48 49 inode->i_ino = new_block; 50 inode_init_owner(inode, NULL, mode); 51 inode->i_mapping->a_ops = &omfs_aops; 52 53 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); 54 switch (mode & S_IFMT) { 55 case S_IFDIR: 56 inode->i_op = &omfs_dir_inops; 57 inode->i_fop = &omfs_dir_operations; 58 inode->i_size = sbi->s_sys_blocksize; 59 inc_nlink(inode); 60 break; 61 case S_IFREG: 62 inode->i_op = &omfs_file_inops; 63 inode->i_fop = &omfs_file_operations; 64 inode->i_size = 0; 65 break; 66 } 67 68 insert_inode_hash(inode); 69 mark_inode_dirty(inode); 70 return inode; 71 fail: 72 make_bad_inode(inode); 73 iput(inode); 74 return ERR_PTR(err); 75 } 76 77 /* 78 * Update the header checksums for a dirty inode based on its contents. 79 * Caller is expected to hold the buffer head underlying oi and mark it 80 * dirty. 81 */ 82 static void omfs_update_checksums(struct omfs_inode *oi) 83 { 84 int xor, i, ofs = 0, count; 85 u16 crc = 0; 86 unsigned char *ptr = (unsigned char *) oi; 87 88 count = be32_to_cpu(oi->i_head.h_body_size); 89 ofs = sizeof(struct omfs_header); 90 91 crc = crc_itu_t(crc, ptr + ofs, count); 92 oi->i_head.h_crc = cpu_to_be16(crc); 93 94 xor = ptr[0]; 95 for (i = 1; i < OMFS_XOR_COUNT; i++) 96 xor ^= ptr[i]; 97 98 oi->i_head.h_check_xor = xor; 99 } 100 101 static int __omfs_write_inode(struct inode *inode, int wait) 102 { 103 struct omfs_inode *oi; 104 struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb); 105 struct buffer_head *bh, *bh2; 106 u64 ctime; 107 int i; 108 int ret = -EIO; 109 int sync_failed = 0; 110 111 /* get current inode since we may have written sibling ptrs etc. */ 112 bh = omfs_bread(inode->i_sb, inode->i_ino); 113 if (!bh) 114 goto out; 115 116 oi = (struct omfs_inode *) bh->b_data; 117 118 oi->i_head.h_self = cpu_to_be64(inode->i_ino); 119 if (S_ISDIR(inode->i_mode)) 120 oi->i_type = OMFS_DIR; 121 else if (S_ISREG(inode->i_mode)) 122 oi->i_type = OMFS_FILE; 123 else { 124 printk(KERN_WARNING "omfs: unknown file type: %d\n", 125 inode->i_mode); 126 goto out_brelse; 127 } 128 129 oi->i_head.h_body_size = cpu_to_be32(sbi->s_sys_blocksize - 130 sizeof(struct omfs_header)); 131 oi->i_head.h_version = 1; 132 oi->i_head.h_type = OMFS_INODE_NORMAL; 133 oi->i_head.h_magic = OMFS_IMAGIC; 134 oi->i_size = cpu_to_be64(inode->i_size); 135 136 ctime = inode->i_ctime.tv_sec * 1000LL + 137 ((inode->i_ctime.tv_nsec + 999)/1000); 138 oi->i_ctime = cpu_to_be64(ctime); 139 140 omfs_update_checksums(oi); 141 142 mark_buffer_dirty(bh); 143 if (wait) { 144 sync_dirty_buffer(bh); 145 if (buffer_req(bh) && !buffer_uptodate(bh)) 146 sync_failed = 1; 147 } 148 149 /* if mirroring writes, copy to next fsblock */ 150 for (i = 1; i < sbi->s_mirrors; i++) { 151 bh2 = omfs_bread(inode->i_sb, inode->i_ino + i); 152 if (!bh2) 153 goto out_brelse; 154 155 memcpy(bh2->b_data, bh->b_data, bh->b_size); 156 mark_buffer_dirty(bh2); 157 if (wait) { 158 sync_dirty_buffer(bh2); 159 if (buffer_req(bh2) && !buffer_uptodate(bh2)) 160 sync_failed = 1; 161 } 162 brelse(bh2); 163 } 164 ret = (sync_failed) ? -EIO : 0; 165 out_brelse: 166 brelse(bh); 167 out: 168 return ret; 169 } 170 171 static int omfs_write_inode(struct inode *inode, struct writeback_control *wbc) 172 { 173 return __omfs_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL); 174 } 175 176 int omfs_sync_inode(struct inode *inode) 177 { 178 return __omfs_write_inode(inode, 1); 179 } 180 181 /* 182 * called when an entry is deleted, need to clear the bits in the 183 * bitmaps. 184 */ 185 static void omfs_evict_inode(struct inode *inode) 186 { 187 truncate_inode_pages_final(&inode->i_data); 188 clear_inode(inode); 189 190 if (inode->i_nlink) 191 return; 192 193 if (S_ISREG(inode->i_mode)) { 194 inode->i_size = 0; 195 omfs_shrink_inode(inode); 196 } 197 198 omfs_clear_range(inode->i_sb, inode->i_ino, 2); 199 } 200 201 struct inode *omfs_iget(struct super_block *sb, ino_t ino) 202 { 203 struct omfs_sb_info *sbi = OMFS_SB(sb); 204 struct omfs_inode *oi; 205 struct buffer_head *bh; 206 u64 ctime; 207 unsigned long nsecs; 208 struct inode *inode; 209 210 inode = iget_locked(sb, ino); 211 if (!inode) 212 return ERR_PTR(-ENOMEM); 213 if (!(inode->i_state & I_NEW)) 214 return inode; 215 216 bh = omfs_bread(inode->i_sb, ino); 217 if (!bh) 218 goto iget_failed; 219 220 oi = (struct omfs_inode *)bh->b_data; 221 222 /* check self */ 223 if (ino != be64_to_cpu(oi->i_head.h_self)) 224 goto fail_bh; 225 226 inode->i_uid = sbi->s_uid; 227 inode->i_gid = sbi->s_gid; 228 229 ctime = be64_to_cpu(oi->i_ctime); 230 nsecs = do_div(ctime, 1000) * 1000L; 231 232 inode->i_atime.tv_sec = ctime; 233 inode->i_mtime.tv_sec = ctime; 234 inode->i_ctime.tv_sec = ctime; 235 inode->i_atime.tv_nsec = nsecs; 236 inode->i_mtime.tv_nsec = nsecs; 237 inode->i_ctime.tv_nsec = nsecs; 238 239 inode->i_mapping->a_ops = &omfs_aops; 240 241 switch (oi->i_type) { 242 case OMFS_DIR: 243 inode->i_mode = S_IFDIR | (S_IRWXUGO & ~sbi->s_dmask); 244 inode->i_op = &omfs_dir_inops; 245 inode->i_fop = &omfs_dir_operations; 246 inode->i_size = sbi->s_sys_blocksize; 247 inc_nlink(inode); 248 break; 249 case OMFS_FILE: 250 inode->i_mode = S_IFREG | (S_IRWXUGO & ~sbi->s_fmask); 251 inode->i_fop = &omfs_file_operations; 252 inode->i_size = be64_to_cpu(oi->i_size); 253 break; 254 } 255 brelse(bh); 256 unlock_new_inode(inode); 257 return inode; 258 fail_bh: 259 brelse(bh); 260 iget_failed: 261 iget_failed(inode); 262 return ERR_PTR(-EIO); 263 } 264 265 static void omfs_put_super(struct super_block *sb) 266 { 267 struct omfs_sb_info *sbi = OMFS_SB(sb); 268 kfree(sbi->s_imap); 269 kfree(sbi); 270 sb->s_fs_info = NULL; 271 } 272 273 static int omfs_statfs(struct dentry *dentry, struct kstatfs *buf) 274 { 275 struct super_block *s = dentry->d_sb; 276 struct omfs_sb_info *sbi = OMFS_SB(s); 277 u64 id = huge_encode_dev(s->s_bdev->bd_dev); 278 279 buf->f_type = OMFS_MAGIC; 280 buf->f_bsize = sbi->s_blocksize; 281 buf->f_blocks = sbi->s_num_blocks; 282 buf->f_files = sbi->s_num_blocks; 283 buf->f_namelen = OMFS_NAMELEN; 284 buf->f_fsid.val[0] = (u32)id; 285 buf->f_fsid.val[1] = (u32)(id >> 32); 286 287 buf->f_bfree = buf->f_bavail = buf->f_ffree = 288 omfs_count_free(s); 289 290 return 0; 291 } 292 293 static const struct super_operations omfs_sops = { 294 .write_inode = omfs_write_inode, 295 .evict_inode = omfs_evict_inode, 296 .put_super = omfs_put_super, 297 .statfs = omfs_statfs, 298 .show_options = generic_show_options, 299 }; 300 301 /* 302 * For Rio Karma, there is an on-disk free bitmap whose location is 303 * stored in the root block. For ReplayTV, there is no such free bitmap 304 * so we have to walk the tree. Both inodes and file data are allocated 305 * from the same map. This array can be big (300k) so we allocate 306 * in units of the blocksize. 307 */ 308 static int omfs_get_imap(struct super_block *sb) 309 { 310 unsigned int bitmap_size, array_size; 311 int count; 312 struct omfs_sb_info *sbi = OMFS_SB(sb); 313 struct buffer_head *bh; 314 unsigned long **ptr; 315 sector_t block; 316 317 bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8); 318 array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize); 319 320 if (sbi->s_bitmap_ino == ~0ULL) 321 goto out; 322 323 sbi->s_imap_size = array_size; 324 sbi->s_imap = kcalloc(array_size, sizeof(unsigned long *), GFP_KERNEL); 325 if (!sbi->s_imap) 326 goto nomem; 327 328 block = clus_to_blk(sbi, sbi->s_bitmap_ino); 329 if (block >= sbi->s_num_blocks) 330 goto nomem; 331 332 ptr = sbi->s_imap; 333 for (count = bitmap_size; count > 0; count -= sb->s_blocksize) { 334 bh = sb_bread(sb, block++); 335 if (!bh) 336 goto nomem_free; 337 *ptr = kmalloc(sb->s_blocksize, GFP_KERNEL); 338 if (!*ptr) { 339 brelse(bh); 340 goto nomem_free; 341 } 342 memcpy(*ptr, bh->b_data, sb->s_blocksize); 343 if (count < sb->s_blocksize) 344 memset((void *)*ptr + count, 0xff, 345 sb->s_blocksize - count); 346 brelse(bh); 347 ptr++; 348 } 349 out: 350 return 0; 351 352 nomem_free: 353 for (count = 0; count < array_size; count++) 354 kfree(sbi->s_imap[count]); 355 356 kfree(sbi->s_imap); 357 nomem: 358 sbi->s_imap = NULL; 359 sbi->s_imap_size = 0; 360 return -ENOMEM; 361 } 362 363 enum { 364 Opt_uid, Opt_gid, Opt_umask, Opt_dmask, Opt_fmask, Opt_err 365 }; 366 367 static const match_table_t tokens = { 368 {Opt_uid, "uid=%u"}, 369 {Opt_gid, "gid=%u"}, 370 {Opt_umask, "umask=%o"}, 371 {Opt_dmask, "dmask=%o"}, 372 {Opt_fmask, "fmask=%o"}, 373 {Opt_err, NULL}, 374 }; 375 376 static int parse_options(char *options, struct omfs_sb_info *sbi) 377 { 378 char *p; 379 substring_t args[MAX_OPT_ARGS]; 380 int option; 381 382 if (!options) 383 return 1; 384 385 while ((p = strsep(&options, ",")) != NULL) { 386 int token; 387 if (!*p) 388 continue; 389 390 token = match_token(p, tokens, args); 391 switch (token) { 392 case Opt_uid: 393 if (match_int(&args[0], &option)) 394 return 0; 395 sbi->s_uid = make_kuid(current_user_ns(), option); 396 if (!uid_valid(sbi->s_uid)) 397 return 0; 398 break; 399 case Opt_gid: 400 if (match_int(&args[0], &option)) 401 return 0; 402 sbi->s_gid = make_kgid(current_user_ns(), option); 403 if (!gid_valid(sbi->s_gid)) 404 return 0; 405 break; 406 case Opt_umask: 407 if (match_octal(&args[0], &option)) 408 return 0; 409 sbi->s_fmask = sbi->s_dmask = option; 410 break; 411 case Opt_dmask: 412 if (match_octal(&args[0], &option)) 413 return 0; 414 sbi->s_dmask = option; 415 break; 416 case Opt_fmask: 417 if (match_octal(&args[0], &option)) 418 return 0; 419 sbi->s_fmask = option; 420 break; 421 default: 422 return 0; 423 } 424 } 425 return 1; 426 } 427 428 static int omfs_fill_super(struct super_block *sb, void *data, int silent) 429 { 430 struct buffer_head *bh, *bh2; 431 struct omfs_super_block *omfs_sb; 432 struct omfs_root_block *omfs_rb; 433 struct omfs_sb_info *sbi; 434 struct inode *root; 435 int ret = -EINVAL; 436 437 save_mount_options(sb, (char *) data); 438 439 sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL); 440 if (!sbi) 441 return -ENOMEM; 442 443 sb->s_fs_info = sbi; 444 445 sbi->s_uid = current_uid(); 446 sbi->s_gid = current_gid(); 447 sbi->s_dmask = sbi->s_fmask = current_umask(); 448 449 if (!parse_options((char *) data, sbi)) 450 goto end; 451 452 sb->s_maxbytes = 0xffffffff; 453 454 sb_set_blocksize(sb, 0x200); 455 456 bh = sb_bread(sb, 0); 457 if (!bh) 458 goto end; 459 460 omfs_sb = (struct omfs_super_block *)bh->b_data; 461 462 if (omfs_sb->s_magic != cpu_to_be32(OMFS_MAGIC)) { 463 if (!silent) 464 printk(KERN_ERR "omfs: Invalid superblock (%x)\n", 465 omfs_sb->s_magic); 466 goto out_brelse_bh; 467 } 468 sb->s_magic = OMFS_MAGIC; 469 470 sbi->s_num_blocks = be64_to_cpu(omfs_sb->s_num_blocks); 471 sbi->s_blocksize = be32_to_cpu(omfs_sb->s_blocksize); 472 sbi->s_mirrors = be32_to_cpu(omfs_sb->s_mirrors); 473 sbi->s_root_ino = be64_to_cpu(omfs_sb->s_root_block); 474 sbi->s_sys_blocksize = be32_to_cpu(omfs_sb->s_sys_blocksize); 475 mutex_init(&sbi->s_bitmap_lock); 476 477 if (sbi->s_num_blocks > OMFS_MAX_BLOCKS) { 478 printk(KERN_ERR "omfs: sysblock number (%llx) is out of range\n", 479 (unsigned long long)sbi->s_num_blocks); 480 goto out_brelse_bh; 481 } 482 483 if (sbi->s_sys_blocksize > PAGE_SIZE) { 484 printk(KERN_ERR "omfs: sysblock size (%d) is out of range\n", 485 sbi->s_sys_blocksize); 486 goto out_brelse_bh; 487 } 488 489 if (sbi->s_blocksize < sbi->s_sys_blocksize || 490 sbi->s_blocksize > OMFS_MAX_BLOCK_SIZE) { 491 printk(KERN_ERR "omfs: block size (%d) is out of range\n", 492 sbi->s_blocksize); 493 goto out_brelse_bh; 494 } 495 496 /* 497 * Use sys_blocksize as the fs block since it is smaller than a 498 * page while the fs blocksize can be larger. 499 */ 500 sb_set_blocksize(sb, sbi->s_sys_blocksize); 501 502 /* 503 * ...and the difference goes into a shift. sys_blocksize is always 504 * a power of two factor of blocksize. 505 */ 506 sbi->s_block_shift = get_bitmask_order(sbi->s_blocksize) - 507 get_bitmask_order(sbi->s_sys_blocksize); 508 509 bh2 = omfs_bread(sb, be64_to_cpu(omfs_sb->s_root_block)); 510 if (!bh2) 511 goto out_brelse_bh; 512 513 omfs_rb = (struct omfs_root_block *)bh2->b_data; 514 515 sbi->s_bitmap_ino = be64_to_cpu(omfs_rb->r_bitmap); 516 sbi->s_clustersize = be32_to_cpu(omfs_rb->r_clustersize); 517 518 if (sbi->s_num_blocks != be64_to_cpu(omfs_rb->r_num_blocks)) { 519 printk(KERN_ERR "omfs: block count discrepancy between " 520 "super and root blocks (%llx, %llx)\n", 521 (unsigned long long)sbi->s_num_blocks, 522 (unsigned long long)be64_to_cpu(omfs_rb->r_num_blocks)); 523 goto out_brelse_bh2; 524 } 525 526 if (sbi->s_bitmap_ino != ~0ULL && 527 sbi->s_bitmap_ino > sbi->s_num_blocks) { 528 printk(KERN_ERR "omfs: free space bitmap location is corrupt " 529 "(%llx, total blocks %llx)\n", 530 (unsigned long long) sbi->s_bitmap_ino, 531 (unsigned long long) sbi->s_num_blocks); 532 goto out_brelse_bh2; 533 } 534 if (sbi->s_clustersize < 1 || 535 sbi->s_clustersize > OMFS_MAX_CLUSTER_SIZE) { 536 printk(KERN_ERR "omfs: cluster size out of range (%d)", 537 sbi->s_clustersize); 538 goto out_brelse_bh2; 539 } 540 541 ret = omfs_get_imap(sb); 542 if (ret) 543 goto out_brelse_bh2; 544 545 sb->s_op = &omfs_sops; 546 547 root = omfs_iget(sb, be64_to_cpu(omfs_rb->r_root_dir)); 548 if (IS_ERR(root)) { 549 ret = PTR_ERR(root); 550 goto out_brelse_bh2; 551 } 552 553 sb->s_root = d_make_root(root); 554 if (!sb->s_root) { 555 ret = -ENOMEM; 556 goto out_brelse_bh2; 557 } 558 printk(KERN_DEBUG "omfs: Mounted volume %s\n", omfs_rb->r_name); 559 560 ret = 0; 561 out_brelse_bh2: 562 brelse(bh2); 563 out_brelse_bh: 564 brelse(bh); 565 end: 566 if (ret) 567 kfree(sbi); 568 return ret; 569 } 570 571 static struct dentry *omfs_mount(struct file_system_type *fs_type, 572 int flags, const char *dev_name, void *data) 573 { 574 return mount_bdev(fs_type, flags, dev_name, data, omfs_fill_super); 575 } 576 577 static struct file_system_type omfs_fs_type = { 578 .owner = THIS_MODULE, 579 .name = "omfs", 580 .mount = omfs_mount, 581 .kill_sb = kill_block_super, 582 .fs_flags = FS_REQUIRES_DEV, 583 }; 584 MODULE_ALIAS_FS("omfs"); 585 586 static int __init init_omfs_fs(void) 587 { 588 return register_filesystem(&omfs_fs_type); 589 } 590 591 static void __exit exit_omfs_fs(void) 592 { 593 unregister_filesystem(&omfs_fs_type); 594 } 595 596 module_init(init_omfs_fs); 597 module_exit(exit_omfs_fs); 598