fs/block_dev.c

   1 /*
   2  *  linux/fs/block_dev.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/mm.h>
  10 #include <linux/fcntl.h>
  11 #include <linux/slab.h>
  12 #include <linux/kmod.h>
  13 #include <linux/major.h>
  14 #include <linux/smp_lock.h>
  15 #include <linux/device_cgroup.h>
  16 #include <linux/highmem.h>
  17 #include <linux/blkdev.h>
  18 #include <linux/module.h>
  19 #include <linux/blkpg.h>
  20 #include <linux/buffer_head.h>
  21 #include <linux/pagevec.h>
  22 #include <linux/writeback.h>
  23 #include <linux/mpage.h>
  24 #include <linux/mount.h>
  25 #include <linux/uio.h>
  26 #include <linux/namei.h>
  27 #include <linux/log2.h>
  28 #include <linux/kmemleak.h>
  29 #include <asm/uaccess.h>
  30 #include "internal.h"
  31 #include <linux/mtd/blktrans.h>
  32 #include <linux/mtd/mtd.h>
  33
  34 struct bdev_inode {
  35         struct block_device bdev;
  36         struct inode vfs_inode;
  37 };
  38
  39 static const struct address_space_operations def_blk_aops;
  40
  41 static inline struct bdev_inode *BDEV_I(struct inode *inode)
  42 {
  43         return container_of(inode, struct bdev_inode, vfs_inode);
  44 }
  45
  46 inline struct block_device *I_BDEV(struct inode *inode)
  47 {
  48         return &BDEV_I(inode)->bdev;
  49 }
  50
  51 EXPORT_SYMBOL(I_BDEV);
  52
  53 static sector_t max_block(struct block_device *bdev)
  54 {
  55         sector_t retval = ~((sector_t)0);
  56         loff_t sz = i_size_read(bdev->bd_inode);
  57
  58         if (sz) {
  59                 unsigned int size = block_size(bdev);
  60                 unsigned int sizebits = blksize_bits(size);
  61                 retval = (sz >> sizebits);
  62         }
  63         return retval;
  64 }
  65
  66 /* Kill _all_ buffers and pagecache , dirty or not.. */
  67 static void kill_bdev(struct block_device *bdev)
  68 {
  69         if (bdev->bd_inode->i_mapping->nrpages == 0)
  70                 return;
  71         invalidate_bh_lrus();
  72         truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
  73 }
  74
  75 int set_blocksize(struct block_device *bdev, int size)
  76 {
  77         /* Size must be a power of two, and between 512 and PAGE_SIZE */
  78         if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
  79                 return -EINVAL;
  80
  81         /* Size cannot be smaller than the size supported by the device */
  82         if (size < bdev_logical_block_size(bdev))
  83                 return -EINVAL;
  84
  85         /* Don't change the size if it is same as current */
  86         if (bdev->bd_block_size != size) {
  87                 sync_blockdev(bdev);
  88                 bdev->bd_block_size = size;
  89                 bdev->bd_inode->i_blkbits = blksize_bits(size);
  90                 kill_bdev(bdev);
  91         }
  92         return 0;
  93 }
  94
  95 EXPORT_SYMBOL(set_blocksize);
  96
  97 int sb_set_blocksize(struct super_block *sb, int size)
  98 {
  99         if (set_blocksize(sb->s_bdev, size))
 100                 return 0;
 101         /* If we get here, we know size is power of two
 102          * and it's value is between 512 and PAGE_SIZE */
 103         sb->s_blocksize = size;
 104         sb->s_blocksize_bits = blksize_bits(size);
 105         return sb->s_blocksize;
 106 }
 107
 108 EXPORT_SYMBOL(sb_set_blocksize);
 109
 110 int sb_min_blocksize(struct super_block *sb, int size)
 111 {
 112         int minsize = bdev_logical_block_size(sb->s_bdev);
 113         if (size < minsize)
 114                 size = minsize;
 115         return sb_set_blocksize(sb, size);
 116 }
 117
 118 EXPORT_SYMBOL(sb_min_blocksize);
 119
 120 static int
 121 blkdev_get_block(struct inode *inode, sector_t iblock,
 122                 struct buffer_head *bh, int create)
 123 {
 124         if (iblock >= max_block(I_BDEV(inode))) {
 125                 if (create)
 126                         return -EIO;
 127
 128                 /*
 129                  * for reads, we're just trying to fill a partial page.
 130                  * return a hole, they will have to call get_block again
 131                  * before they can fill it, and they will get -EIO at that
 132                  * time
 133                  */
 134                 return 0;
 135         }
 136         bh->b_bdev = I_BDEV(inode);
 137         bh->b_blocknr = iblock;
 138         set_buffer_mapped(bh);
 139         return 0;
 140 }
 141
 142 static int
 143 blkdev_get_blocks(struct inode *inode, sector_t iblock,
 144                 struct buffer_head *bh, int create)
 145 {
 146         sector_t end_block = max_block(I_BDEV(inode));
 147         unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
 148
 149         if ((iblock + max_blocks) > end_block) {
 150                 max_blocks = end_block - iblock;
 151                 if ((long)max_blocks <= 0) {
 152                         if (create)
 153                                 return -EIO;    /* write fully beyond EOF */
 154                         /*
 155                          * It is a read which is fully beyond EOF.  We return
 156                          * a !buffer_mapped buffer
 157                          */
 158                         max_blocks = 0;
 159                 }
 160         }
 161
 162         bh->b_bdev = I_BDEV(inode);
 163         bh->b_blocknr = iblock;
 164         bh->b_size = max_blocks << inode->i_blkbits;
 165         if (max_blocks)
 166                 set_buffer_mapped(bh);
 167         return 0;
 168 }
 169
 170 static ssize_t
 171 blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
 172                         loff_t offset, unsigned long nr_segs)
 173 {
 174         struct file *file = iocb->ki_filp;
 175         struct inode *inode = file->f_mapping->host;
 176
 177         return __blockdev_direct_IO(rw, iocb, inode, I_BDEV(inode), iov, offset,
 178                                     nr_segs, blkdev_get_blocks, NULL, NULL, 0);
 179 }
 180
 181 int __sync_blockdev(struct block_device *bdev, int wait)
 182 {
 183         if (!bdev)
 184                 return 0;
 185         if (!wait)
 186                 return filemap_flush(bdev->bd_inode->i_mapping);
 187         return filemap_write_and_wait(bdev->bd_inode->i_mapping);
 188 }
 189
 190 /*
 191  * Write out and wait upon all the dirty data associated with a block
 192  * device via its mapping.  Does not take the superblock lock.
 193  */
 194 int sync_blockdev(struct block_device *bdev)
 195 {
 196         return __sync_blockdev(bdev, 1);
 197 }
 198 EXPORT_SYMBOL(sync_blockdev);
 199
 200 /*
 201  * Write out and wait upon all dirty data associated with this
 202  * device.   Filesystem data as well as the underlying block
 203  * device.  Takes the superblock lock.
 204  */
 205 int fsync_bdev(struct block_device *bdev)
 206 {
 207         struct super_block *sb = get_super(bdev);
 208         if (sb) {
 209                 int res = sync_filesystem(sb);
 210                 drop_super(sb);
 211                 return res;
 212         }
 213         return sync_blockdev(bdev);
 214 }
 215 EXPORT_SYMBOL(fsync_bdev);
 216
 217 /**
 218  * freeze_bdev  --  lock a filesystem and force it into a consistent state
 219  * @bdev:       blockdevice to lock
 220  *
 221  * If a superblock is found on this device, we take the s_umount semaphore
 222  * on it to make sure nobody unmounts until the snapshot creation is done.
 223  * The reference counter (bd_fsfreeze_count) guarantees that only the last
 224  * unfreeze process can unfreeze the frozen filesystem actually when multiple
 225  * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
 226  * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
 227  * actually.
 228  */
 229 struct super_block *freeze_bdev(struct block_device *bdev)
 230 {
 231         struct super_block *sb;
 232         int error = 0;
 233
 234         mutex_lock(&bdev->bd_fsfreeze_mutex);
 235         if (++bdev->bd_fsfreeze_count > 1) {
 236                 /*
 237                  * We don't even need to grab a reference - the first call
 238                  * to freeze_bdev grab an active reference and only the last
 239                  * thaw_bdev drops it.
 240                  */
 241                 sb = get_super(bdev);
 242                 drop_super(sb);
 243                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
 244                 return sb;
 245         }
 246
 247         sb = get_active_super(bdev);
 248         if (!sb)
 249                 goto out;
 250         error = freeze_super(sb);
 251         if (error) {
 252                 deactivate_super(sb);
 253                 bdev->bd_fsfreeze_count--;
 254                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
 255                 return ERR_PTR(error);
 256         }
 257         deactivate_super(sb);
 258  out:
 259         sync_blockdev(bdev);
 260         mutex_unlock(&bdev->bd_fsfreeze_mutex);
 261         return sb;      /* thaw_bdev releases s->s_umount */
 262 }
 263 EXPORT_SYMBOL(freeze_bdev);
 264
 265 /**
 266  * thaw_bdev  -- unlock filesystem
 267  * @bdev:       blockdevice to unlock
 268  * @sb:         associated superblock
 269  *
 270  * Unlocks the filesystem and marks it writeable again after freeze_bdev().
 271  */
 272 int thaw_bdev(struct block_device *bdev, struct super_block *sb)
 273 {
 274         int error = -EINVAL;
 275
 276         mutex_lock(&bdev->bd_fsfreeze_mutex);
 277         if (!bdev->bd_fsfreeze_count)
 278                 goto out;
 279
 280         error = 0;
 281         if (--bdev->bd_fsfreeze_count > 0)
 282                 goto out;
 283
 284         if (!sb)
 285                 goto out;
 286
 287         error = thaw_super(sb);
 288         if (error) {
 289                 bdev->bd_fsfreeze_count++;
 290                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
 291                 return error;
 292         }
 293 out:
 294         mutex_unlock(&bdev->bd_fsfreeze_mutex);
 295         return 0;
 296 }
 297 EXPORT_SYMBOL(thaw_bdev);
 298
 299 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
 300 {
 301         return block_write_full_page(page, blkdev_get_block, wbc);
 302 }
 303
 304 static int blkdev_readpage(struct file * file, struct page * page)
 305 {
 306         return block_read_full_page(page, blkdev_get_block);
 307 }
 308
 309 static int blkdev_write_begin(struct file *file, struct address_space *mapping,
 310                         loff_t pos, unsigned len, unsigned flags,
 311                         struct page **pagep, void **fsdata)
 312 {
 313         return block_write_begin(mapping, pos, len, flags, pagep,
 314                                  blkdev_get_block);
 315 }
 316
 317 static int blkdev_write_end(struct file *file, struct address_space *mapping,
 318                         loff_t pos, unsigned len, unsigned copied,
 319                         struct page *page, void *fsdata)
 320 {
 321         int ret;
 322         ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
 323
 324         unlock_page(page);
 325         page_cache_release(page);
 326
 327         return ret;
 328 }
 329
 330 /*
 331  * private llseek:
 332  * for a block special file file->f_path.dentry->d_inode->i_size is zero
 333  * so we compute the size by hand (just as in block_read/write above)
 334  */
 335 static loff_t block_llseek(struct file *file, loff_t offset, int origin)
 336 {
 337         struct inode *bd_inode = file->f_mapping->host;
 338         loff_t size;
 339         loff_t retval;
 340
 341         mutex_lock(&bd_inode->i_mutex);
 342         size = i_size_read(bd_inode);
 343
 344         switch (origin) {
 345                 case 2:
 346                         offset += size;
 347                         break;
 348                 case 1:
 349                         offset += file->f_pos;
 350         }
 351         retval = -EINVAL;
 352         if (offset >= 0 && offset <= size) {
 353                 if (offset != file->f_pos) {
 354                         file->f_pos = offset;
 355                 }
 356                 retval = offset;
 357         }
 358         mutex_unlock(&bd_inode->i_mutex);
 359         return retval;
 360 }
 361
 362 int blkdev_fsync(struct file *filp, int datasync)
 363 {
 364         struct inode *bd_inode = filp->f_mapping->host;
 365         struct block_device *bdev = I_BDEV(bd_inode);
 366         int error;
 367
 368         /*
 369          * There is no need to serialise calls to blkdev_issue_flush with
 370          * i_mutex and doing so causes performance issues with concurrent
 371          * O_SYNC writers to a block device.
 372          */
 373         mutex_unlock(&bd_inode->i_mutex);
 374
 375         error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL, BLKDEV_IFL_WAIT);
 376         if (error == -EOPNOTSUPP)
 377                 error = 0;
 378
 379         mutex_lock(&bd_inode->i_mutex);
 380
 381         return error;
 382 }
 383 EXPORT_SYMBOL(blkdev_fsync);
 384
 385 /*
 386  * pseudo-fs
 387  */
 388
 389 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
 390 static struct kmem_cache * bdev_cachep __read_mostly;
 391
 392 static struct inode *bdev_alloc_inode(struct super_block *sb)
 393 {
 394         struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
 395         if (!ei)
 396                 return NULL;
 397         return &ei->vfs_inode;
 398 }
 399
 400 static void bdev_destroy_inode(struct inode *inode)
 401 {
 402         struct bdev_inode *bdi = BDEV_I(inode);
 403
 404         kmem_cache_free(bdev_cachep, bdi);
 405 }
 406
 407 static void init_once(void *foo)
 408 {
 409         struct bdev_inode *ei = (struct bdev_inode *) foo;
 410         struct block_device *bdev = &ei->bdev;
 411
 412         memset(bdev, 0, sizeof(*bdev));
 413         mutex_init(&bdev->bd_mutex);
 414         INIT_LIST_HEAD(&bdev->bd_inodes);
 415         INIT_LIST_HEAD(&bdev->bd_list);
 416 #ifdef CONFIG_SYSFS
 417         INIT_LIST_HEAD(&bdev->bd_holder_list);
 418 #endif
 419         inode_init_once(&ei->vfs_inode);
 420         /* Initialize mutex for freeze. */
 421         mutex_init(&bdev->bd_fsfreeze_mutex);
 422 }
 423
 424 static inline void __bd_forget(struct inode *inode)
 425 {
 426         list_del_init(&inode->i_devices);
 427         inode->i_bdev = NULL;
 428         inode->i_mapping = &inode->i_data;
 429 }
 430
 431 static void bdev_evict_inode(struct inode *inode)
 432 {
 433         struct block_device *bdev = &BDEV_I(inode)->bdev;
 434         struct list_head *p;
 435         truncate_inode_pages(&inode->i_data, 0);
 436         invalidate_inode_buffers(inode); /* is it needed here? */
 437         end_writeback(inode);
 438         spin_lock(&bdev_lock);
 439         while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
 440                 __bd_forget(list_entry(p, struct inode, i_devices));
 441         }
 442         list_del_init(&bdev->bd_list);
 443         spin_unlock(&bdev_lock);
 444 }
 445
 446 static const struct super_operations bdev_sops = {
 447         .statfs = simple_statfs,
 448         .alloc_inode = bdev_alloc_inode,
 449         .destroy_inode = bdev_destroy_inode,
 450         .drop_inode = generic_delete_inode,
 451         .evict_inode = bdev_evict_inode,
 452 };
 453
 454 static int bd_get_sb(struct file_system_type *fs_type,
 455         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 456 {
 457         return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
 458 }
 459
 460 static struct file_system_type bd_type = {
 461         .name           = "bdev",
 462         .get_sb         = bd_get_sb,
 463         .kill_sb        = kill_anon_super,
 464 };
 465
 466 struct super_block *blockdev_superblock __read_mostly;
 467
 468 void __init bdev_cache_init(void)
 469 {
 470         int err;
 471         struct vfsmount *bd_mnt;
 472
 473         bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
 474                         0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
 475                                 SLAB_MEM_SPREAD|SLAB_PANIC),
 476                         init_once);
 477         err = register_filesystem(&bd_type);
 478         if (err)
 479                 panic("Cannot register bdev pseudo-fs");
 480         bd_mnt = kern_mount(&bd_type);
 481         if (IS_ERR(bd_mnt))
 482                 panic("Cannot create bdev pseudo-fs");
 483         /*
 484          * This vfsmount structure is only used to obtain the
 485          * blockdev_superblock, so tell kmemleak not to report it.
 486          */
 487         kmemleak_not_leak(bd_mnt);
 488         blockdev_superblock = bd_mnt->mnt_sb;   /* For writeback */
 489 }
 490
 491 /*
 492  * Most likely _very_ bad one - but then it's hardly critical for small
 493  * /dev and can be fixed when somebody will need really large one.
 494  * Keep in mind that it will be fed through icache hash function too.
 495  */
 496 static inline unsigned long hash(dev_t dev)
 497 {
 498         return MAJOR(dev)+MINOR(dev);
 499 }
 500
 501 static int bdev_test(struct inode *inode, void *data)
 502 {
 503         return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
 504 }
 505
 506 static int bdev_set(struct inode *inode, void *data)
 507 {
 508         BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
 509         return 0;
 510 }
 511
 512 static LIST_HEAD(all_bdevs);
 513
 514 struct block_device *bdget(dev_t dev)
 515 {
 516         struct block_device *bdev;
 517         struct inode *inode;
 518
 519         inode = iget5_locked(blockdev_superblock, hash(dev),
 520                         bdev_test, bdev_set, &dev);
 521
 522         if (!inode)
 523                 return NULL;
 524
 525         bdev = &BDEV_I(inode)->bdev;
 526
 527         if (inode->i_state & I_NEW) {
 528                 bdev->bd_contains = NULL;
 529                 bdev->bd_inode = inode;
 530                 bdev->bd_block_size = (1 << inode->i_blkbits);
 531                 bdev->bd_part_count = 0;
 532                 bdev->bd_invalidated = 0;
 533                 inode->i_mode = S_IFBLK;
 534                 inode->i_rdev = dev;
 535                 inode->i_bdev = bdev;
 536                 inode->i_data.a_ops = &def_blk_aops;
 537                 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
 538                 inode->i_data.backing_dev_info = &default_backing_dev_info;
 539                 spin_lock(&bdev_lock);
 540                 list_add(&bdev->bd_list, &all_bdevs);
 541                 spin_unlock(&bdev_lock);
 542                 unlock_new_inode(inode);
 543         }
 544         return bdev;
 545 }
 546
 547 EXPORT_SYMBOL(bdget);
 548
 549 /**
 550  * bdgrab -- Grab a reference to an already referenced block device
 551  * @bdev:       Block device to grab a reference to.
 552  */
 553 struct block_device *bdgrab(struct block_device *bdev)
 554 {
 555         atomic_inc(&bdev->bd_inode->i_count);
 556         return bdev;
 557 }
 558
 559 long nr_blockdev_pages(void)
 560 {
 561         struct block_device *bdev;
 562         long ret = 0;
 563         spin_lock(&bdev_lock);
 564         list_for_each_entry(bdev, &all_bdevs, bd_list) {
 565                 ret += bdev->bd_inode->i_mapping->nrpages;
 566         }
 567         spin_unlock(&bdev_lock);
 568         return ret;
 569 }
 570
 571 void bdput(struct block_device *bdev)
 572 {
 573         iput(bdev->bd_inode);
 574 }
 575
 576 EXPORT_SYMBOL(bdput);
 577
 578 static struct block_device *bd_acquire(struct inode *inode)
 579 {
 580         struct block_device *bdev;
 581
 582         spin_lock(&bdev_lock);
 583         bdev = inode->i_bdev;
 584         if (bdev) {
 585                 atomic_inc(&bdev->bd_inode->i_count);
 586                 spin_unlock(&bdev_lock);
 587                 return bdev;
 588         }
 589         spin_unlock(&bdev_lock);
 590
 591         bdev = bdget(inode->i_rdev);
 592         if (bdev) {
 593                 spin_lock(&bdev_lock);
 594                 if (!inode->i_bdev) {
 595                         /*
 596                          * We take an additional bd_inode->i_count for inode,
 597                          * and it's released in clear_inode() of inode.
 598                          * So, we can access it via ->i_mapping always
 599                          * without igrab().
 600                          */
 601                         atomic_inc(&bdev->bd_inode->i_count);
 602                         inode->i_bdev = bdev;
 603                         inode->i_mapping = bdev->bd_inode->i_mapping;
 604                         list_add(&inode->i_devices, &bdev->bd_inodes);
 605                 }
 606                 spin_unlock(&bdev_lock);
 607         }
 608         return bdev;
 609 }
 610
 611 /* Call when you free inode */
 612
 613 void bd_forget(struct inode *inode)
 614 {
 615         struct block_device *bdev = NULL;
 616
 617         spin_lock(&bdev_lock);
 618         if (inode->i_bdev) {
 619                 if (!sb_is_blkdev_sb(inode->i_sb))
 620                         bdev = inode->i_bdev;
 621                 __bd_forget(inode);
 622         }
 623         spin_unlock(&bdev_lock);
 624
 625         if (bdev)
 626                 iput(bdev->bd_inode);
 627 }
 628
 629 /**
 630  * bd_may_claim - test whether a block device can be claimed
 631  * @bdev: block device of interest
 632  * @whole: whole block device containing @bdev, may equal @bdev
 633  * @holder: holder trying to claim @bdev
 634  *
 635  * Test whther @bdev can be claimed by @holder.
 636  *
 637  * CONTEXT:
 638  * spin_lock(&bdev_lock).
 639  *
 640  * RETURNS:
 641  * %true if @bdev can be claimed, %false otherwise.
 642  */
 643 static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
 644                          void *holder)
 645 {
 646         if (bdev->bd_holder == holder)
 647                 return true;     /* already a holder */
 648         else if (bdev->bd_holder != NULL)
 649                 return false;    /* held by someone else */
 650         else if (bdev->bd_contains == bdev)
 651                 return true;     /* is a whole device which isn't held */
 652
 653         else if (whole->bd_holder == bd_claim)
 654                 return true;     /* is a partition of a device that is being partitioned */
 655         else if (whole->bd_holder != NULL)
 656                 return false;    /* is a partition of a held device */
 657         else
 658                 return true;     /* is a partition of an un-held device */
 659 }
 660
 661 /**
 662  * bd_prepare_to_claim - prepare to claim a block device
 663  * @bdev: block device of interest
 664  * @whole: the whole device containing @bdev, may equal @bdev
 665  * @holder: holder trying to claim @bdev
 666  *
 667  * Prepare to claim @bdev.  This function fails if @bdev is already
 668  * claimed by another holder and waits if another claiming is in
 669  * progress.  This function doesn't actually claim.  On successful
 670  * return, the caller has ownership of bd_claiming and bd_holder[s].
 671  *
 672  * CONTEXT:
 673  * spin_lock(&bdev_lock).  Might release bdev_lock, sleep and regrab
 674  * it multiple times.
 675  *
 676  * RETURNS:
 677  * 0 if @bdev can be claimed, -EBUSY otherwise.
 678  */
 679 static int bd_prepare_to_claim(struct block_device *bdev,
 680                                struct block_device *whole, void *holder)
 681 {
 682 retry:
 683         /* if someone else claimed, fail */
 684         if (!bd_may_claim(bdev, whole, holder))
 685                 return -EBUSY;
 686
 687         /* if claiming is already in progress, wait for it to finish */
 688         if (whole->bd_claiming) {
 689                 wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);
 690                 DEFINE_WAIT(wait);
 691
 692                 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
 693                 spin_unlock(&bdev_lock);
 694                 schedule();
 695                 finish_wait(wq, &wait);
 696                 spin_lock(&bdev_lock);
 697                 goto retry;
 698         }
 699
 700         /* yay, all mine */
 701         return 0;
 702 }
 703
 704 /**
 705  * bd_start_claiming - start claiming a block device
 706  * @bdev: block device of interest
 707  * @holder: holder trying to claim @bdev
 708  *
 709  * @bdev is about to be opened exclusively.  Check @bdev can be opened
 710  * exclusively and mark that an exclusive open is in progress.  Each
 711  * successful call to this function must be matched with a call to
 712  * either bd_finish_claiming() or bd_abort_claiming() (which do not
 713  * fail).
 714  *
 715  * This function is used to gain exclusive access to the block device
 716  * without actually causing other exclusive open attempts to fail. It
 717  * should be used when the open sequence itself requires exclusive
 718  * access but may subsequently fail.
 719  *
 720  * CONTEXT:
 721  * Might sleep.
 722  *
 723  * RETURNS:
 724  * Pointer to the block device containing @bdev on success, ERR_PTR()
 725  * value on failure.
 726  */
 727 static struct block_device *bd_start_claiming(struct block_device *bdev,
 728                                               void *holder)
 729 {
 730         struct gendisk *disk;
 731         struct block_device *whole;
 732         int partno, err;
 733
 734         might_sleep();
 735
 736         /*
 737          * @bdev might not have been initialized properly yet, look up
 738          * and grab the outer block device the hard way.
 739          */
 740         disk = get_gendisk(bdev->bd_dev, &partno);
 741         if (!disk)
 742                 return ERR_PTR(-ENXIO);
 743
 744         whole = bdget_disk(disk, 0);
 745         module_put(disk->fops->owner);
 746         put_disk(disk);
 747         if (!whole)
 748                 return ERR_PTR(-ENOMEM);
 749
 750         /* prepare to claim, if successful, mark claiming in progress */
 751         spin_lock(&bdev_lock);
 752
 753         err = bd_prepare_to_claim(bdev, whole, holder);
 754         if (err == 0) {
 755                 whole->bd_claiming = holder;
 756                 spin_unlock(&bdev_lock);
 757                 return whole;
 758         } else {
 759                 spin_unlock(&bdev_lock);
 760                 bdput(whole);
 761                 return ERR_PTR(err);
 762         }
 763 }
 764
 765 /* releases bdev_lock */
 766 static void __bd_abort_claiming(struct block_device *whole, void *holder)
 767 {
 768         BUG_ON(whole->bd_claiming != holder);
 769         whole->bd_claiming = NULL;
 770         wake_up_bit(&whole->bd_claiming, 0);
 771
 772         spin_unlock(&bdev_lock);
 773         bdput(whole);
 774 }
 775
 776 /**
 777  * bd_abort_claiming - abort claiming a block device
 778  * @whole: whole block device returned by bd_start_claiming()
 779  * @holder: holder trying to claim @bdev
 780  *
 781  * Abort a claiming block started by bd_start_claiming().  Note that
 782  * @whole is not the block device to be claimed but the whole device
 783  * returned by bd_start_claiming().
 784  *
 785  * CONTEXT:
 786  * Grabs and releases bdev_lock.
 787  */
 788 static void bd_abort_claiming(struct block_device *whole, void *holder)
 789 {
 790         spin_lock(&bdev_lock);
 791         __bd_abort_claiming(whole, holder);             /* releases bdev_lock */
 792 }
 793
 794 /* increment holders when we have a legitimate claim. requires bdev_lock */
 795 static void __bd_claim(struct block_device *bdev, struct block_device *whole,
 796                                         void *holder)
 797 {
 798         /* note that for a whole device bd_holders
 799          * will be incremented twice, and bd_holder will
 800          * be set to bd_claim before being set to holder
 801          */
 802         whole->bd_holders++;
 803         whole->bd_holder = bd_claim;
 804         bdev->bd_holders++;
 805         bdev->bd_holder = holder;
 806 }
 807
 808 /**
 809  * bd_finish_claiming - finish claiming a block device
 810  * @bdev: block device of interest (passed to bd_start_claiming())
 811  * @whole: whole block device returned by bd_start_claiming()
 812  * @holder: holder trying to claim @bdev
 813  *
 814  * Finish a claiming block started by bd_start_claiming().
 815  *
 816  * CONTEXT:
 817  * Grabs and releases bdev_lock.
 818  */
 819 static void bd_finish_claiming(struct block_device *bdev,
 820                                 struct block_device *whole, void *holder)
 821 {
 822         spin_lock(&bdev_lock);
 823         BUG_ON(!bd_may_claim(bdev, whole, holder));
 824         __bd_claim(bdev, whole, holder);
 825         __bd_abort_claiming(whole, holder); /* not actually an abort */
 826 }
 827
 828 /**
 829  * bd_claim - claim a block device
 830  * @bdev: block device to claim
 831  * @holder: holder trying to claim @bdev
 832  *
 833  * Try to claim @bdev which must have been opened successfully.
 834  *
 835  * CONTEXT:
 836  * Might sleep.
 837  *
 838  * RETURNS:
 839  * 0 if successful, -EBUSY if @bdev is already claimed.
 840  */
 841 int bd_claim(struct block_device *bdev, void *holder)
 842 {
 843         struct block_device *whole = bdev->bd_contains;
 844         int res;
 845
 846         might_sleep();
 847
 848         spin_lock(&bdev_lock);
 849         res = bd_prepare_to_claim(bdev, whole, holder);
 850         if (res == 0)
 851                 __bd_claim(bdev, whole, holder);
 852         spin_unlock(&bdev_lock);
 853
 854         return res;
 855 }
 856 EXPORT_SYMBOL(bd_claim);
 857
 858 void bd_release(struct block_device *bdev)
 859 {
 860         spin_lock(&bdev_lock);
 861         if (!--bdev->bd_contains->bd_holders)
 862                 bdev->bd_contains->bd_holder = NULL;
 863         if (!--bdev->bd_holders)
 864                 bdev->bd_holder = NULL;
 865         spin_unlock(&bdev_lock);
 866 }
 867
 868 EXPORT_SYMBOL(bd_release);
 869
 870 #ifdef CONFIG_SYSFS
 871 /*
 872  * Functions for bd_claim_by_kobject / bd_release_from_kobject
 873  *
 874  *     If a kobject is passed to bd_claim_by_kobject()
 875  *     and the kobject has a parent directory,
 876  *     following symlinks are created:
 877  *        o from the kobject to the claimed bdev
 878  *        o from "holders" directory of the bdev to the parent of the kobject
 879  *     bd_release_from_kobject() removes these symlinks.
 880  *
 881  *     Example:
 882  *        If /dev/dm-0 maps to /dev/sda, kobject corresponding to
 883  *        /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
 884  *           /sys/block/dm-0/slaves/sda --> /sys/block/sda
 885  *           /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
 886  */
 887
 888 static int add_symlink(struct kobject *from, struct kobject *to)
 889 {
 890         if (!from || !to)
 891                 return 0;
 892         return sysfs_create_link(from, to, kobject_name(to));
 893 }
 894
 895 static void del_symlink(struct kobject *from, struct kobject *to)
 896 {
 897         if (!from || !to)
 898                 return;
 899         sysfs_remove_link(from, kobject_name(to));
 900 }
 901
 902 /*
 903  * 'struct bd_holder' contains pointers to kobjects symlinked by
 904  * bd_claim_by_kobject.
 905  * It's connected to bd_holder_list which is protected by bdev->bd_sem.
 906  */
 907 struct bd_holder {
 908         struct list_head list;  /* chain of holders of the bdev */
 909         int count;              /* references from the holder */
 910         struct kobject *sdir;   /* holder object, e.g. "/block/dm-0/slaves" */
 911         struct kobject *hdev;   /* e.g. "/block/dm-0" */
 912         struct kobject *hdir;   /* e.g. "/block/sda/holders" */
 913         struct kobject *sdev;   /* e.g. "/block/sda" */
 914 };
 915
 916 /*
 917  * Get references of related kobjects at once.
 918  * Returns 1 on success. 0 on failure.
 919  *
 920  * Should call bd_holder_release_dirs() after successful use.
 921  */
 922 static int bd_holder_grab_dirs(struct block_device *bdev,
 923                         struct bd_holder *bo)
 924 {
 925         if (!bdev || !bo)
 926                 return 0;
 927
 928         bo->sdir = kobject_get(bo->sdir);
 929         if (!bo->sdir)
 930                 return 0;
 931
 932         bo->hdev = kobject_get(bo->sdir->parent);
 933         if (!bo->hdev)
 934                 goto fail_put_sdir;
 935
 936         bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
 937         if (!bo->sdev)
 938                 goto fail_put_hdev;
 939
 940         bo->hdir = kobject_get(bdev->bd_part->holder_dir);
 941         if (!bo->hdir)
 942                 goto fail_put_sdev;
 943
 944         return 1;
 945
 946 fail_put_sdev:
 947         kobject_put(bo->sdev);
 948 fail_put_hdev:
 949         kobject_put(bo->hdev);
 950 fail_put_sdir:
 951         kobject_put(bo->sdir);
 952
 953         return 0;
 954 }
 955
 956 /* Put references of related kobjects at once. */
 957 static void bd_holder_release_dirs(struct bd_holder *bo)
 958 {
 959         kobject_put(bo->hdir);
 960         kobject_put(bo->sdev);
 961         kobject_put(bo->hdev);
 962         kobject_put(bo->sdir);
 963 }
 964
 965 static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
 966 {
 967         struct bd_holder *bo;
 968
 969         bo = kzalloc(sizeof(*bo), GFP_KERNEL);
 970         if (!bo)
 971                 return NULL;
 972
 973         bo->count = 1;
 974         bo->sdir = kobj;
 975
 976         return bo;
 977 }
 978
 979 static void free_bd_holder(struct bd_holder *bo)
 980 {
 981         kfree(bo);
 982 }
 983
 984 /**
 985  * find_bd_holder - find matching struct bd_holder from the block device
 986  *
 987  * @bdev:       struct block device to be searched
 988  * @bo:         target struct bd_holder
 989  *
 990  * Returns matching entry with @bo in @bdev->bd_holder_list.
 991  * If found, increment the reference count and return the pointer.
 992  * If not found, returns NULL.
 993  */
 994 static struct bd_holder *find_bd_holder(struct block_device *bdev,
 995                                         struct bd_holder *bo)
 996 {
 997         struct bd_holder *tmp;
 998
 999         list_for_each_entry(tmp, &bdev->bd_holder_list, list)
1000                 if (tmp->sdir == bo->sdir) {
1001                         tmp->count++;
1002                         return tmp;
1003                 }
1004
1005         return NULL;
1006 }
1007
1008 /**
1009  * add_bd_holder - create sysfs symlinks for bd_claim() relationship
1010  *
1011  * @bdev:       block device to be bd_claimed
1012  * @bo:         preallocated and initialized by alloc_bd_holder()
1013  *
1014  * Add @bo to @bdev->bd_holder_list, create symlinks.
1015  *
1016  * Returns 0 if symlinks are created.
1017  * Returns -ve if something fails.
1018  */
1019 static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
1020 {
1021         int err;
1022
1023         if (!bo)
1024                 return -EINVAL;
1025
1026         if (!bd_holder_grab_dirs(bdev, bo))
1027                 return -EBUSY;
1028
1029         err = add_symlink(bo->sdir, bo->sdev);
1030         if (err)
1031                 return err;
1032
1033         err = add_symlink(bo->hdir, bo->hdev);
1034         if (err) {
1035                 del_symlink(bo->sdir, bo->sdev);
1036                 return err;
1037         }
1038
1039         list_add_tail(&bo->list, &bdev->bd_holder_list);
1040         return 0;
1041 }
1042
1043 /**
1044  * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
1045  *
1046  * @bdev:       block device to be bd_claimed
1047  * @kobj:       holder's kobject
1048  *
1049  * If there is matching entry with @kobj in @bdev->bd_holder_list
1050  * and no other bd_claim() from the same kobject,
1051  * remove the struct bd_holder from the list, delete symlinks for it.
1052  *
1053  * Returns a pointer to the struct bd_holder when it's removed from the list
1054  * and ready to be freed.
1055  * Returns NULL if matching claim isn't found or there is other bd_claim()
1056  * by the same kobject.
1057  */
1058 static struct bd_holder *del_bd_holder(struct block_device *bdev,
1059                                         struct kobject *kobj)
1060 {
1061         struct bd_holder *bo;
1062
1063         list_for_each_entry(bo, &bdev->bd_holder_list, list) {
1064                 if (bo->sdir == kobj) {
1065                         bo->count--;
1066                         BUG_ON(bo->count < 0);
1067                         if (!bo->count) {
1068                                 list_del(&bo->list);
1069                                 del_symlink(bo->sdir, bo->sdev);
1070                                 del_symlink(bo->hdir, bo->hdev);
1071                                 bd_holder_release_dirs(bo);
1072                                 return bo;
1073                         }
1074                         break;
1075                 }
1076         }
1077
1078         return NULL;
1079 }
1080
1081 /**
1082  * bd_claim_by_kobject - bd_claim() with additional kobject signature
1083  *
1084  * @bdev:       block device to be claimed
1085  * @holder:     holder's signature
1086  * @kobj:       holder's kobject
1087  *
1088  * Do bd_claim() and if it succeeds, create sysfs symlinks between
1089  * the bdev and the holder's kobject.
1090  * Use bd_release_from_kobject() when relesing the claimed bdev.
1091  *
1092  * Returns 0 on success. (same as bd_claim())
1093  * Returns errno on failure.
1094  */
1095 static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
1096                                 struct kobject *kobj)
1097 {
1098         int err;
1099         struct bd_holder *bo, *found;
1100
1101         if (!kobj)
1102                 return -EINVAL;
1103
1104         bo = alloc_bd_holder(kobj);
1105         if (!bo)
1106                 return -ENOMEM;
1107
1108         mutex_lock(&bdev->bd_mutex);
1109
1110         err = bd_claim(bdev, holder);
1111         if (err)
1112                 goto fail;
1113
1114         found = find_bd_holder(bdev, bo);
1115         if (found)
1116                 goto fail;
1117
1118         err = add_bd_holder(bdev, bo);
1119         if (err)
1120                 bd_release(bdev);
1121         else
1122                 bo = NULL;
1123 fail:
1124         mutex_unlock(&bdev->bd_mutex);
1125         free_bd_holder(bo);
1126         return err;
1127 }
1128
1129 /**
1130  * bd_release_from_kobject - bd_release() with additional kobject signature
1131  *
1132  * @bdev:       block device to be released
1133  * @kobj:       holder's kobject
1134  *
1135  * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
1136  */
1137 static void bd_release_from_kobject(struct block_device *bdev,
1138                                         struct kobject *kobj)
1139 {
1140         if (!kobj)
1141                 return;
1142
1143         mutex_lock(&bdev->bd_mutex);
1144         bd_release(bdev);
1145         free_bd_holder(del_bd_holder(bdev, kobj));
1146         mutex_unlock(&bdev->bd_mutex);
1147 }
1148
1149 /**
1150  * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
1151  *
1152  * @bdev:       block device to be claimed
1153  * @holder:     holder's signature
1154  * @disk:       holder's gendisk
1155  *
1156  * Call bd_claim_by_kobject() with getting @disk->slave_dir.
1157  */
1158 int bd_claim_by_disk(struct block_device *bdev, void *holder,
1159                         struct gendisk *disk)
1160 {
1161         return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
1162 }
1163 EXPORT_SYMBOL_GPL(bd_claim_by_disk);
1164
1165 /**
1166  * bd_release_from_disk - wrapper function for bd_release_from_kobject()
1167  *
1168  * @bdev:       block device to be claimed
1169  * @disk:       holder's gendisk
1170  *
1171  * Call bd_release_from_kobject() and put @disk->slave_dir.
1172  */
1173 void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
1174 {
1175         bd_release_from_kobject(bdev, disk->slave_dir);
1176         kobject_put(disk->slave_dir);
1177 }
1178 EXPORT_SYMBOL_GPL(bd_release_from_disk);
1179 #endif
1180
1181 /*
1182  * Tries to open block device by device number.  Use it ONLY if you
1183  * really do not have anything better - i.e. when you are behind a
1184  * truly sucky interface and all you are given is a device number.  _Never_
1185  * to be used for internal purposes.  If you ever need it - reconsider
1186  * your API.
1187  */
1188 struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
1189 {
1190         struct block_device *bdev = bdget(dev);
1191         int err = -ENOMEM;
1192         if (bdev)
1193                 err = blkdev_get(bdev, mode);
1194         return err ? ERR_PTR(err) : bdev;
1195 }
1196
1197 EXPORT_SYMBOL(open_by_devnum);
1198
1199 /**
1200  * flush_disk - invalidates all buffer-cache entries on a disk
1201  *
1202  * @bdev:      struct block device to be flushed
1203  *
1204  * Invalidates all buffer-cache entries on a disk. It should be called
1205  * when a disk has been changed -- either by a media change or online
1206  * resize.
1207  */
1208 static void flush_disk(struct block_device *bdev)
1209 {
1210         if (__invalidate_device(bdev)) {
1211                 char name[BDEVNAME_SIZE] = "";
1212
1213                 if (bdev->bd_disk)
1214                         disk_name(bdev->bd_disk, 0, name);
1215                 printk(KERN_WARNING "VFS: busy inodes on changed media or "
1216                        "resized disk %s\n", name);
1217         }
1218
1219         if (!bdev->bd_disk)
1220                 return;
1221         if (disk_partitionable(bdev->bd_disk))
1222                 bdev->bd_invalidated = 1;
1223 }
1224
1225 /**
1226  * check_disk_size_change - checks for disk size change and adjusts bdev size.
1227  * @disk: struct gendisk to check
1228  * @bdev: struct bdev to adjust.
1229  *
1230  * This routine checks to see if the bdev size does not match the disk size
1231  * and adjusts it if it differs.
1232  */
1233 void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
1234 {
1235         loff_t disk_size, bdev_size;
1236
1237         disk_size = (loff_t)get_capacity(disk) << 9;
1238         bdev_size = i_size_read(bdev->bd_inode);
1239         if (disk_size != bdev_size) {
1240                 char name[BDEVNAME_SIZE];
1241
1242                 disk_name(disk, 0, name);
1243                 printk(KERN_INFO
1244                        "%s: detected capacity change from %lld to %lld\n",
1245                        name, bdev_size, disk_size);
1246                 i_size_write(bdev->bd_inode, disk_size);
1247                 flush_disk(bdev);
1248         }
1249 }
1250 EXPORT_SYMBOL(check_disk_size_change);
1251
1252 /**
1253  * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
1254  * @disk: struct gendisk to be revalidated
1255  *
1256  * This routine is a wrapper for lower-level driver's revalidate_disk
1257  * call-backs.  It is used to do common pre and post operations needed
1258  * for all revalidate_disk operations.
1259  */
1260 int revalidate_disk(struct gendisk *disk)
1261 {
1262         struct block_device *bdev;
1263         int ret = 0;
1264
1265         if (disk->fops->revalidate_disk)
1266                 ret = disk->fops->revalidate_disk(disk);
1267
1268         bdev = bdget_disk(disk, 0);
1269         if (!bdev)
1270                 return ret;
1271
1272         mutex_lock(&bdev->bd_mutex);
1273         check_disk_size_change(disk, bdev);
1274         mutex_unlock(&bdev->bd_mutex);
1275         bdput(bdev);
1276         return ret;
1277 }
1278 EXPORT_SYMBOL(revalidate_disk);
1279
1280 /*
1281  * This routine checks whether a removable media has been changed,
1282  * and invalidates all buffer-cache-entries in that case. This
1283  * is a relatively slow routine, so we have to try to minimize using
1284  * it. Thus it is called only upon a 'mount' or 'open'. This
1285  * is the best way of combining speed and utility, I think.
1286  * People changing diskettes in the middle of an operation deserve
1287  * to lose :-)
1288  */
1289 int check_disk_change(struct block_device *bdev)
1290 {
1291         struct gendisk *disk = bdev->bd_disk;
1292         const struct block_device_operations *bdops = disk->fops;
1293
1294         if (!bdops->media_changed)
1295                 return 0;
1296         if (!bdops->media_changed(bdev->bd_disk))
1297                 return 0;
1298
1299         flush_disk(bdev);
1300         if (bdops->revalidate_disk)
1301                 bdops->revalidate_disk(bdev->bd_disk);
1302         return 1;
1303 }
1304
1305 EXPORT_SYMBOL(check_disk_change);
1306
1307 void bd_set_size(struct block_device *bdev, loff_t size)
1308 {
1309         unsigned bsize = bdev_logical_block_size(bdev);
1310
1311         bdev->bd_inode->i_size = size;
1312         while (bsize < PAGE_CACHE_SIZE) {
1313                 if (size & bsize)
1314                         break;
1315                 bsize <<= 1;
1316         }
1317         bdev->bd_block_size = bsize;
1318         bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1319 }
1320 EXPORT_SYMBOL(bd_set_size);
1321
1322 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1323
1324 /*
1325  * bd_mutex locking:
1326  *
1327  *  mutex_lock(part->bd_mutex)
1328  *    mutex_lock_nested(whole->bd_mutex, 1)
1329  */
1330
1331 static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1332 {
1333         struct gendisk *disk;
1334         int ret;
1335         int partno;
1336         int perm = 0;
1337
1338         if (mode & FMODE_READ)
1339                 perm |= MAY_READ;
1340         if (mode & FMODE_WRITE)
1341                 perm |= MAY_WRITE;
1342         /*
1343          * hooks: /n/, see "layering violations".
1344          */
1345         if (!for_part) {
1346                 ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1347                 if (ret != 0) {
1348                         bdput(bdev);
1349                         return ret;
1350                 }
1351         }
1352
1353  restart:
1354
1355         ret = -ENXIO;
1356         disk = get_gendisk(bdev->bd_dev, &partno);
1357         if (!disk)
1358                 goto out;
1359
1360         mutex_lock_nested(&bdev->bd_mutex, for_part);
1361         if (!bdev->bd_openers) {
1362                 bdev->bd_disk = disk;
1363                 bdev->bd_contains = bdev;
1364                 if (!partno) {
1365                         struct backing_dev_info *bdi;
1366
1367                         ret = -ENXIO;
1368                         bdev->bd_part = disk_get_part(disk, partno);
1369                         if (!bdev->bd_part)
1370                                 goto out_clear;
1371
1372                         if (disk->fops->open) {
1373                                 ret = disk->fops->open(bdev, mode);
1374                                 if (ret == -ERESTARTSYS) {
1375                                         /* Lost a race with 'disk' being
1376                                          * deleted, try again.
1377                                          * See md.c
1378                                          */
1379                                         disk_put_part(bdev->bd_part);
1380                                         bdev->bd_part = NULL;
1381                                         module_put(disk->fops->owner);
1382                                         put_disk(disk);
1383                                         bdev->bd_disk = NULL;
1384                                         mutex_unlock(&bdev->bd_mutex);
1385                                         goto restart;
1386                                 }
1387                                 if (ret)
1388                                         goto out_clear;
1389                         }
1390                         if (!bdev->bd_openers) {
1391                                 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1392                                 bdi = blk_get_backing_dev_info(bdev);
1393                                 if (bdi == NULL)
1394                                         bdi = &default_backing_dev_info;
1395                                 bdev->bd_inode->i_data.backing_dev_info = bdi;
1396                         }
1397                         if (bdev->bd_invalidated)
1398                                 rescan_partitions(disk, bdev);
1399                 } else {
1400                         struct block_device *whole;
1401                         whole = bdget_disk(disk, 0);
1402                         ret = -ENOMEM;
1403                         if (!whole)
1404                                 goto out_clear;
1405                         BUG_ON(for_part);
1406                         ret = __blkdev_get(whole, mode, 1);
1407                         if (ret)
1408                                 goto out_clear;
1409                         bdev->bd_contains = whole;
1410                         bdev->bd_inode->i_data.backing_dev_info =
1411                            whole->bd_inode->i_data.backing_dev_info;
1412                         bdev->bd_part = disk_get_part(disk, partno);
1413                         if (!(disk->flags & GENHD_FL_UP) ||
1414                             !bdev->bd_part || !bdev->bd_part->nr_sects) {
1415                                 ret = -ENXIO;
1416                                 goto out_clear;
1417                         }
1418                         bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1419                 }
1420         } else {
1421                 module_put(disk->fops->owner);
1422                 put_disk(disk);
1423                 disk = NULL;
1424                 if (bdev->bd_contains == bdev) {
1425                         if (bdev->bd_disk->fops->open) {
1426                                 ret = bdev->bd_disk->fops->open(bdev, mode);
1427                                 if (ret)
1428                                         goto out_unlock_bdev;
1429                         }
1430                         if (bdev->bd_invalidated)
1431                                 rescan_partitions(bdev->bd_disk, bdev);
1432                 }
1433         }
1434         bdev->bd_openers++;
1435         if (for_part)
1436                 bdev->bd_part_count++;
1437         mutex_unlock(&bdev->bd_mutex);
1438         return 0;
1439
1440  out_clear:
1441         disk_put_part(bdev->bd_part);
1442         bdev->bd_disk = NULL;
1443         bdev->bd_part = NULL;
1444         bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1445         if (bdev != bdev->bd_contains)
1446                 __blkdev_put(bdev->bd_contains, mode, 1);
1447         bdev->bd_contains = NULL;
1448  out_unlock_bdev:
1449         mutex_unlock(&bdev->bd_mutex);
1450  out:
1451         if (disk)
1452                 module_put(disk->fops->owner);
1453         put_disk(disk);
1454         bdput(bdev);
1455
1456         return ret;
1457 }
1458
1459 int blkdev_get(struct block_device *bdev, fmode_t mode)
1460 {
1461         return __blkdev_get(bdev, mode, 0);
1462 }
1463 EXPORT_SYMBOL(blkdev_get);
1464
1465 static int blkdev_open(struct inode * inode, struct file * filp)
1466 {
1467         struct block_device *whole = NULL;
1468         struct block_device *bdev;
1469         int res;
1470
1471         /*
1472          * Preserve backwards compatibility and allow large file access
1473          * even if userspace doesn't ask for it explicitly. Some mkfs
1474          * binary needs it. We might want to drop this workaround
1475          * during an unstable branch.
1476          */
1477         filp->f_flags |= O_LARGEFILE;
1478
1479         if (filp->f_flags & O_NDELAY)
1480                 filp->f_mode |= FMODE_NDELAY;
1481         if (filp->f_flags & O_EXCL)
1482                 filp->f_mode |= FMODE_EXCL;
1483         if ((filp->f_flags & O_ACCMODE) == 3)
1484                 filp->f_mode |= FMODE_WRITE_IOCTL;
1485
1486         bdev = bd_acquire(inode);
1487         if (bdev == NULL)
1488                 return -ENOMEM;
1489
1490         if (filp->f_mode & FMODE_EXCL) {
1491                 whole = bd_start_claiming(bdev, filp);
1492                 if (IS_ERR(whole)) {
1493                         bdput(bdev);
1494                         return PTR_ERR(whole);
1495                 }
1496         }
1497
1498         filp->f_mapping = bdev->bd_inode->i_mapping;
1499
1500         res = blkdev_get(bdev, filp->f_mode);
1501
1502         if (whole) {
1503                 if (res == 0)
1504                         bd_finish_claiming(bdev, whole, filp);
1505                 else
1506                         bd_abort_claiming(whole, filp);
1507         }
1508
1509         return res;
1510 }
1511
1512 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1513 {
1514         int ret = 0;
1515         struct gendisk *disk = bdev->bd_disk;
1516         struct block_device *victim = NULL;
1517
1518         mutex_lock_nested(&bdev->bd_mutex, for_part);
1519         if (for_part)
1520                 bdev->bd_part_count--;
1521
1522         if (!--bdev->bd_openers) {
1523                 sync_blockdev(bdev);
1524                 kill_bdev(bdev);
1525         }
1526         if (bdev->bd_contains == bdev) {
1527                 if (disk->fops->release)
1528                         ret = disk->fops->release(disk, mode);
1529         }
1530         if (!bdev->bd_openers) {
1531                 struct module *owner = disk->fops->owner;
1532
1533                 put_disk(disk);
1534                 module_put(owner);
1535                 disk_put_part(bdev->bd_part);
1536                 bdev->bd_part = NULL;
1537                 bdev->bd_disk = NULL;
1538                 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1539                 if (bdev != bdev->bd_contains)
1540                         victim = bdev->bd_contains;
1541                 bdev->bd_contains = NULL;
1542         }
1543         mutex_unlock(&bdev->bd_mutex);
1544         bdput(bdev);
1545         if (victim)
1546                 __blkdev_put(victim, mode, 1);
1547         return ret;
1548 }
1549
1550 int blkdev_put(struct block_device *bdev, fmode_t mode)
1551 {
1552         return __blkdev_put(bdev, mode, 0);
1553 }
1554 EXPORT_SYMBOL(blkdev_put);
1555
1556 static int blkdev_close(struct inode * inode, struct file * filp)
1557 {
1558         struct block_device *bdev = I_BDEV(filp->f_mapping->host);
1559         if (bdev->bd_holder == filp)
1560                 bd_release(bdev);
1561         return blkdev_put(bdev, filp->f_mode);
1562 }
1563
1564 static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1565 {
1566         struct block_device *bdev = I_BDEV(file->f_mapping->host);
1567         fmode_t mode = file->f_mode;
1568
1569         /*
1570          * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1571          * to updated it before every ioctl.
1572          */
1573         if (file->f_flags & O_NDELAY)
1574                 mode |= FMODE_NDELAY;
1575         else
1576                 mode &= ~FMODE_NDELAY;
1577
1578         return blkdev_ioctl(bdev, mode, cmd, arg);
1579 }
1580
1581 /*
1582  * Write data to the block device.  Only intended for the block device itself
1583  * and the raw driver which basically is a fake block device.
1584  *
1585  * Does not take i_mutex for the write and thus is not for general purpose
1586  * use.
1587  */
1588 ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
1589                          unsigned long nr_segs, loff_t pos)
1590 {
1591         struct file *file = iocb->ki_filp;
1592         ssize_t ret;
1593
1594         BUG_ON(iocb->ki_pos != pos);
1595
1596         ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
1597         if (ret > 0 || ret == -EIOCBQUEUED) {
1598                 ssize_t err;
1599
1600                 err = generic_write_sync(file, pos, ret);
1601                 if (err < 0 && ret > 0)
1602                         ret = err;
1603         }
1604         return ret;
1605 }
1606 EXPORT_SYMBOL_GPL(blkdev_aio_write);
1607
1608 /*
1609  * Try to release a page associated with block device when the system
1610  * is under memory pressure.
1611  */
1612 static int blkdev_releasepage(struct page *page, gfp_t wait)
1613 {
1614         struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1615
1616         if (super && super->s_op->bdev_try_to_free_page)
1617                 return super->s_op->bdev_try_to_free_page(super, page, wait);
1618
1619         return try_to_free_buffers(page);
1620 }
1621
1622 static const struct address_space_operations def_blk_aops = {
1623         .readpage       = blkdev_readpage,
1624         .writepage      = blkdev_writepage,
1625         .sync_page      = block_sync_page,
1626         .write_begin    = blkdev_write_begin,
1627         .write_end      = blkdev_write_end,
1628         .writepages     = generic_writepages,
1629         .releasepage    = blkdev_releasepage,
1630         .direct_IO      = blkdev_direct_IO,
1631 };
1632
1633
1634 ssize_t mydo_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
1635 {
1636     unsigned long buf_addr = (unsigned long)buf;
1637     if((memcmp(filp->f_mapping->host->i_bdev->bd_disk->disk_name, "mtdblock", 8) == 0) &&(buf_addr >= 0xc0000000))// kernel mem is usb tran &&(buf_addr >= 0xc0000000)
1638     {
1639         struct mtd_blktrans_dev *dev;
1640         struct mtd_blktrans_ops *tr;
1641         struct mtd_info *mtd;
1642
1643         dev = (filp->f_mapping->host->i_bdev->bd_disk->private_data);
1644         mtd = dev->mtd;
1645         /*if((buf_addr < 0xc0000000)&&(mtd->name[0]=='u' &&mtd->name[3]=='r' && mtd->name[4]==0)) // user part
1646         {
1647             return(do_sync_read(filp, buf,len,ppos));
1648         }*/
1649         tr = dev->tr;
1650                 if (!tr->readsect)
1651                 {
1652                         return(do_sync_read(filp, buf,len,ppos));
1653             }
1654         //printk("mydo_sync_read buf = 0x%lx LBA = 0x%lx len = 0x%x \n",buf, (unsigned long)(*ppos>>9),len);
1655         if(tr->readsect(dev, (unsigned long)(*ppos>>9), len>>9, buf))
1656         {
1657             return 0 ;
1658         }
1659         *ppos += len;
1660         return len;
1661     }
1662
1663     else
1664     {
1665         return(do_sync_read(filp, buf,len,ppos));
1666     }
1667 }
1668
1669 ssize_t mydo_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
1670 {
1671     unsigned long buf_addr = (unsigned long)buf;
1672     if((memcmp(filp->f_mapping->host->i_bdev->bd_disk->disk_name, "mtdblock", 8) == 0) &&(buf_addr >= 0xc0000000))// kernel mem is usb tran &&(buf_addr >= 0xc0000000)
1673     {
1674         struct mtd_blktrans_dev *dev;
1675         struct mtd_blktrans_ops *tr;
1676         struct mtd_info *mtd;
1677
1678         dev = (filp->f_mapping->host->i_bdev->bd_disk->private_data);
1679
1680         mtd = dev->mtd;
1681         /*if((buf_addr < 0xc0000000)&&(mtd->name[0]=='u' &&mtd->name[3]=='r' && mtd->name[4]==0))
1682         {
1683             return(do_sync_write(filp, buf,len,ppos));
1684         }*/
1685
1686         tr = dev->tr;
1687
1688                 if (!tr->writesect)
1689                         return 0;
1690         //printk("mydo_sync_write buf = 0x%lx LBA = 0x%lx len = 0x%x \n",buf, (unsigned long)(*ppos>>9),len);
1691         if(tr->writesect(dev, (unsigned long)(*ppos>>9), len>>9, buf))
1692         {
1693             return 0 ;
1694         }
1695         *ppos += len;
1696         return len;
1697     }
1698
1699     else
1700     {
1701         return(do_sync_write(filp, buf,len,ppos));
1702     }
1703 }
1704
1705
1706 const struct file_operations def_blk_fops = {
1707         .open           = blkdev_open,
1708         .release        = blkdev_close,
1709         .llseek         = block_llseek,
1710         .read           = mydo_sync_read,
1711         .write          = mydo_sync_write,
1712         .aio_read       = generic_file_aio_read,
1713         .aio_write      = blkdev_aio_write,
1714         .mmap           = generic_file_mmap,
1715         .fsync          = blkdev_fsync,
1716         .unlocked_ioctl = block_ioctl,
1717 #ifdef CONFIG_COMPAT
1718         .compat_ioctl   = compat_blkdev_ioctl,
1719 #endif
1720         .splice_read    = generic_file_splice_read,
1721         .splice_write   = generic_file_splice_write,
1722 };
1723
1724 int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1725 {
1726         int res;
1727         mm_segment_t old_fs = get_fs();
1728         set_fs(KERNEL_DS);
1729         res = blkdev_ioctl(bdev, 0, cmd, arg);
1730         set_fs(old_fs);
1731         return res;
1732 }
1733
1734 EXPORT_SYMBOL(ioctl_by_bdev);
1735
1736 /**
1737  * lookup_bdev  - lookup a struct block_device by name
1738  * @pathname:   special file representing the block device
1739  *
1740  * Get a reference to the blockdevice at @pathname in the current
1741  * namespace if possible and return it.  Return ERR_PTR(error)
1742  * otherwise.
1743  */
1744 struct block_device *lookup_bdev(const char *pathname)
1745 {
1746         struct block_device *bdev;
1747         struct inode *inode;
1748         struct path path;
1749         int error;
1750
1751         if (!pathname || !*pathname)
1752                 return ERR_PTR(-EINVAL);
1753
1754         error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1755         if (error)
1756                 return ERR_PTR(error);
1757
1758         inode = path.dentry->d_inode;
1759         error = -ENOTBLK;
1760         if (!S_ISBLK(inode->i_mode))
1761                 goto fail;
1762         error = -EACCES;
1763         if (path.mnt->mnt_flags & MNT_NODEV)
1764                 goto fail;
1765         error = -ENOMEM;
1766         bdev = bd_acquire(inode);
1767         if (!bdev)
1768                 goto fail;
1769 out:
1770         path_put(&path);
1771         return bdev;
1772 fail:
1773         bdev = ERR_PTR(error);
1774         goto out;
1775 }
1776 EXPORT_SYMBOL(lookup_bdev);
1777
1778 /**
1779  * open_bdev_exclusive  -  open a block device by name and set it up for use
1780  *
1781  * @path:       special file representing the block device
1782  * @mode:       FMODE_... combination to pass be used
1783  * @holder:     owner for exclusion
1784  *
1785  * Open the blockdevice described by the special file at @path, claim it
1786  * for the @holder.
1787  */
1788 struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *holder)
1789 {
1790         struct block_device *bdev, *whole;
1791         int error;
1792
1793         bdev = lookup_bdev(path);
1794         if (IS_ERR(bdev))
1795                 return bdev;
1796
1797         whole = bd_start_claiming(bdev, holder);
1798         if (IS_ERR(whole)) {
1799                 bdput(bdev);
1800                 return whole;
1801         }
1802
1803         error = blkdev_get(bdev, mode);
1804         if (error)
1805                 goto out_abort_claiming;
1806
1807         error = -EACCES;
1808         if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
1809                 goto out_blkdev_put;
1810
1811         bd_finish_claiming(bdev, whole, holder);
1812         return bdev;
1813
1814 out_blkdev_put:
1815         blkdev_put(bdev, mode);
1816 out_abort_claiming:
1817         bd_abort_claiming(whole, holder);
1818         return ERR_PTR(error);
1819 }
1820
1821 EXPORT_SYMBOL(open_bdev_exclusive);
1822
1823 /**
1824  * close_bdev_exclusive  -  close a blockdevice opened by open_bdev_exclusive()
1825  *
1826  * @bdev:       blockdevice to close
1827  * @mode:       mode, must match that used to open.
1828  *
1829  * This is the counterpart to open_bdev_exclusive().
1830  */
1831 void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
1832 {
1833         bd_release(bdev);
1834         blkdev_put(bdev, mode);
1835 }
1836
1837 EXPORT_SYMBOL(close_bdev_exclusive);
1838
1839 int __invalidate_device(struct block_device *bdev)
1840 {
1841         struct super_block *sb = get_super(bdev);
1842         int res = 0;
1843
1844         if (sb) {
1845                 /*
1846                  * no need to lock the super, get_super holds the
1847                  * read mutex so the filesystem cannot go away
1848                  * under us (->put_super runs with the write lock
1849                  * hold).
1850                  */
1851                 shrink_dcache_sb(sb);
1852                 res = invalidate_inodes(sb);
1853                 drop_super(sb);
1854         }
1855         invalidate_bdev(bdev);
1856         return res;
1857 }
1858 EXPORT_SYMBOL(__invalidate_device);