Merge branch 'for-2.6.28' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.28' of git://git.kernel.dk/linux-2.6-block: (132 commits)
  doc/cdrom: Trvial documentation error, file not present
  block_dev: fix kernel-doc in new functions
  block: add some comments around the bio read-write flags
  block: mark bio_split_pool static
  block: Find bio sector offset given idx and offset
  block: gendisk integrity wrapper
  block: Switch blk_integrity_compare from bdev to gendisk
  block: Fix double put in blk_integrity_unregister
  block: Introduce integrity data ownership flag
  block: revert part of d7533ad0e132f92e75c1b2eb7c26387b25a583c1
  bio.h: Remove unused conditional code
  block: remove end_{queued|dequeued}_request()
  block: change elevator to use __blk_end_request()
  gdrom: change to use __blk_end_request()
  memstick: change to use __blk_end_request()
  virtio_blk: change to use __blk_end_request()
  blktrace: use BLKTRACE_BDEV_SIZE as the name size for setup structure
  block: add lld busy state exporting interface
  block: Fix blk_start_queueing() to not kick a stopped queue
  include blktrace_api.h in headers_install
  ...

6 files changed, 502 insertions, 292 deletions

diff --git a/fs/bio-integrity.c b/fs/bio-integrity.c
index c3e174b35fe6..19caf7c962ac 100644
--- a/fs/bio-integrity.c
+++ b/fs/bio-integrity.c
@@ -107,7 +107,8 @@ void bio_integrity_free(struct bio *bio, struct bio_set *bs)
         BUG_ON(bip == NULL);
 
         /* A cloned bio doesn't own the integrity metadata */
-        if (!bio_flagged(bio, BIO_CLONED) && bip->bip_buf != NULL)
+        if (!bio_flagged(bio, BIO_CLONED) && !bio_flagged(bio, BIO_FS_INTEGRITY)
+            && bip->bip_buf != NULL)
                 kfree(bip->bip_buf);
 
         mempool_free(bip->bip_vec, bs->bvec_pools[bip->bip_pool]);
@@ -150,6 +151,24 @@ int bio_integrity_add_page(struct bio *bio, struct page *page,
 }
 EXPORT_SYMBOL(bio_integrity_add_page);
 
+static int bdev_integrity_enabled(struct block_device *bdev, int rw)
+{
+        struct blk_integrity *bi = bdev_get_integrity(bdev);
+
+        if (bi == NULL)
+                return 0;
+
+        if (rw == READ && bi->verify_fn != NULL &&
+            (bi->flags & INTEGRITY_FLAG_READ))
+                return 1;
+
+        if (rw == WRITE && bi->generate_fn != NULL &&
+            (bi->flags & INTEGRITY_FLAG_WRITE))
+                return 1;
+
+        return 0;
+}
+
 /**
  * bio_integrity_enabled - Check whether integrity can be passed
  * @bio:        bio to check
@@ -313,6 +332,14 @@ static void bio_integrity_generate(struct bio *bio)
         }
 }
 
+static inline unsigned short blk_integrity_tuple_size(struct blk_integrity *bi)
+{
+        if (bi)
+                return bi->tuple_size;
+
+        return 0;
+}
+
 /**
  * bio_integrity_prep - Prepare bio for integrity I/O
  * @bio:        bio to prepare
diff --git a/fs/bio.c b/fs/bio.c
index 3cba7ae34d75..77a55bcceedb 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -30,7 +30,7 @@
 
 static struct kmem_cache *bio_slab __read_mostly;
 
-mempool_t *bio_split_pool __read_mostly;
+static mempool_t *bio_split_pool __read_mostly;
 
 /*
  * if you change this list, also change bvec_alloc or things will
@@ -60,25 +60,46 @@ struct bio_vec *bvec_alloc_bs(gfp_t gfp_mask, int nr, unsigned long *idx, struct
         struct bio_vec *bvl;
 
         /*
-         * see comment near bvec_array define!
+         * If 'bs' is given, lookup the pool and do the mempool alloc.
+         * If not, this is a bio_kmalloc() allocation and just do a
+         * kzalloc() for the exact number of vecs right away.
          */
-        switch (nr) {
-                case   1        : *idx = 0; break;
-                case   2 ...   4: *idx = 1; break;
-                case   5 ...  16: *idx = 2; break;
-                case  17 ...  64: *idx = 3; break;
-                case  65 ... 128: *idx = 4; break;
-                case 129 ... BIO_MAX_PAGES: *idx = 5; break;
+        if (bs) {
+                /*
+                 * see comment near bvec_array define!
+                 */
+                switch (nr) {
+                case 1:
+                        *idx = 0;
+                        break;
+                case 2 ... 4:
+                        *idx = 1;
+                        break;
+                case 5 ... 16:
+                        *idx = 2;
+                        break;
+                case 17 ... 64:
+                        *idx = 3;
+                        break;
+                case 65 ... 128:
+                        *idx = 4;
+                        break;
+                case 129 ... BIO_MAX_PAGES:
+                        *idx = 5;
+                        break;
                 default:
                         return NULL;
-        }
-        /*
-         * idx now points to the pool we want to allocate from
-         */
+                }
 
-        bvl = mempool_alloc(bs->bvec_pools[*idx], gfp_mask);
-        if (bvl)
-                memset(bvl, 0, bvec_nr_vecs(*idx) * sizeof(struct bio_vec));
+                /*
+                 * idx now points to the pool we want to allocate from
+                 */
+                bvl = mempool_alloc(bs->bvec_pools[*idx], gfp_mask);
+                if (bvl)
+                        memset(bvl, 0,
+                                bvec_nr_vecs(*idx) * sizeof(struct bio_vec));
+        } else
+                bvl = kzalloc(nr * sizeof(struct bio_vec), gfp_mask);
 
         return bvl;
 }
@@ -107,10 +128,17 @@ static void bio_fs_destructor(struct bio *bio)
         bio_free(bio, fs_bio_set);
 }
 
+static void bio_kmalloc_destructor(struct bio *bio)
+{
+        kfree(bio->bi_io_vec);
+        kfree(bio);
+}
+
 void bio_init(struct bio *bio)
 {
         memset(bio, 0, sizeof(*bio));
         bio->bi_flags = 1 << BIO_UPTODATE;
+        bio->bi_comp_cpu = -1;
         atomic_set(&bio->bi_cnt, 1);
 }
 
@@ -118,19 +146,25 @@ void bio_init(struct bio *bio)
  * bio_alloc_bioset - allocate a bio for I/O
  * @gfp_mask:   the GFP_ mask given to the slab allocator
  * @nr_iovecs:  number of iovecs to pre-allocate
- * @bs:         the bio_set to allocate from
+ * @bs:         the bio_set to allocate from. If %NULL, just use kmalloc
  *
  * Description:
- *   bio_alloc_bioset will first try it's on mempool to satisfy the allocation.
+ *   bio_alloc_bioset will first try its own mempool to satisfy the allocation.
  *   If %__GFP_WAIT is set then we will block on the internal pool waiting
- *   for a &struct bio to become free.
+ *   for a &struct bio to become free. If a %NULL @bs is passed in, we will
+ *   fall back to just using @kmalloc to allocate the required memory.
  *
  *   allocate bio and iovecs from the memory pools specified by the
- *   bio_set structure.
+ *   bio_set structure, or @kmalloc if none given.
  **/
 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 {
-        struct bio *bio = mempool_alloc(bs->bio_pool, gfp_mask);
+        struct bio *bio;
+
+        if (bs)
+                bio = mempool_alloc(bs->bio_pool, gfp_mask);
+        else
+                bio = kmalloc(sizeof(*bio), gfp_mask);
 
         if (likely(bio)) {
                 struct bio_vec *bvl = NULL;
@@ -141,7 +175,10 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 
                         bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx, bs);
                         if (unlikely(!bvl)) {
-                                mempool_free(bio, bs->bio_pool);
+                                if (bs)
+                                        mempool_free(bio, bs->bio_pool);
+                                else
+                                        kfree(bio);
                                 bio = NULL;
                                 goto out;
                         }
@@ -164,6 +201,23 @@ struct bio *bio_alloc(gfp_t gfp_mask, int nr_iovecs)
         return bio;
 }
 
+/*
+ * Like bio_alloc(), but doesn't use a mempool backing. This means that
+ * it CAN fail, but while bio_alloc() can only be used for allocations
+ * that have a short (finite) life span, bio_kmalloc() should be used
+ * for more permanent bio allocations (like allocating some bio's for
+ * initalization or setup purposes).
+ */
+struct bio *bio_kmalloc(gfp_t gfp_mask, int nr_iovecs)
+{
+        struct bio *bio = bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
+
+        if (bio)
+                bio->bi_destructor = bio_kmalloc_destructor;
+
+        return bio;
+}
+
 void zero_fill_bio(struct bio *bio)
 {
         unsigned long flags;
@@ -208,14 +262,6 @@ inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
         return bio->bi_phys_segments;
 }
 
-inline int bio_hw_segments(struct request_queue *q, struct bio *bio)
-{
-        if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
-                blk_recount_segments(q, bio);
-
-        return bio->bi_hw_segments;
-}
-
 /**
  *      __bio_clone     -       clone a bio
  *      @bio: destination bio
@@ -350,8 +396,7 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
          */
 
         while (bio->bi_phys_segments >= q->max_phys_segments
-               || bio->bi_hw_segments >= q->max_hw_segments
-               || BIOVEC_VIRT_OVERSIZE(bio->bi_size)) {
+               || bio->bi_phys_segments >= q->max_hw_segments) {
 
                 if (retried_segments)
                         return 0;
@@ -395,13 +440,11 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
         }
 
         /* If we may be able to merge these biovecs, force a recount */
-        if (bio->bi_vcnt && (BIOVEC_PHYS_MERGEABLE(bvec-1, bvec) ||
-            BIOVEC_VIRT_MERGEABLE(bvec-1, bvec)))
+        if (bio->bi_vcnt && (BIOVEC_PHYS_MERGEABLE(bvec-1, bvec)))
                 bio->bi_flags &= ~(1 << BIO_SEG_VALID);
 
         bio->bi_vcnt++;
         bio->bi_phys_segments++;
-        bio->bi_hw_segments++;
  done:
         bio->bi_size += len;
         return len;
@@ -449,16 +492,19 @@ int bio_add_page(struct bio *bio, struct page *page, unsigned int len,
 
 struct bio_map_data {
         struct bio_vec *iovecs;
-        int nr_sgvecs;
         struct sg_iovec *sgvecs;
+        int nr_sgvecs;
+        int is_our_pages;
 };
 
 static void bio_set_map_data(struct bio_map_data *bmd, struct bio *bio,
-                             struct sg_iovec *iov, int iov_count)
+                             struct sg_iovec *iov, int iov_count,
+                             int is_our_pages)
 {
         memcpy(bmd->iovecs, bio->bi_io_vec, sizeof(struct bio_vec) * bio->bi_vcnt);
         memcpy(bmd->sgvecs, iov, sizeof(struct sg_iovec) * iov_count);
         bmd->nr_sgvecs = iov_count;
+        bmd->is_our_pages = is_our_pages;
         bio->bi_private = bmd;
 }
 
@@ -493,7 +539,8 @@ static struct bio_map_data *bio_alloc_map_data(int nr_segs, int iov_count,
 }
 
 static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
-                          struct sg_iovec *iov, int iov_count, int uncopy)
+                          struct sg_iovec *iov, int iov_count, int uncopy,
+                          int do_free_page)
 {
         int ret = 0, i;
         struct bio_vec *bvec;
@@ -536,7 +583,7 @@ static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
                         }
                 }
 
-                if (uncopy)
+                if (do_free_page)
                         __free_page(bvec->bv_page);
         }
 
@@ -553,10 +600,11 @@ static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
 int bio_uncopy_user(struct bio *bio)
 {
         struct bio_map_data *bmd = bio->bi_private;
-        int ret;
-
-        ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs, bmd->nr_sgvecs, 1);
+        int ret = 0;
 
+        if (!bio_flagged(bio, BIO_NULL_MAPPED))
+                ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs,
+                                     bmd->nr_sgvecs, 1, bmd->is_our_pages);
         bio_free_map_data(bmd);
         bio_put(bio);
         return ret;
@@ -565,16 +613,20 @@ int bio_uncopy_user(struct bio *bio)
 /**
  *      bio_copy_user_iov       -       copy user data to bio
  *      @q: destination block queue
+ *      @map_data: pointer to the rq_map_data holding pages (if necessary)
  *      @iov:   the iovec.
  *      @iov_count: number of elements in the iovec
  *      @write_to_vm: bool indicating writing to pages or not
+ *      @gfp_mask: memory allocation flags
  *
  *      Prepares and returns a bio for indirect user io, bouncing data
  *      to/from kernel pages as necessary. Must be paired with
  *      call bio_uncopy_user() on io completion.
  */
-struct bio *bio_copy_user_iov(struct request_queue *q, struct sg_iovec *iov,
-                              int iov_count, int write_to_vm)
+struct bio *bio_copy_user_iov(struct request_queue *q,
+                              struct rq_map_data *map_data,
+                              struct sg_iovec *iov, int iov_count,
+                              int write_to_vm, gfp_t gfp_mask)
 {
         struct bio_map_data *bmd;
         struct bio_vec *bvec;
@@ -597,25 +649,38 @@ struct bio *bio_copy_user_iov(struct request_queue *q, struct sg_iovec *iov,
                 len += iov[i].iov_len;
         }
 
-        bmd = bio_alloc_map_data(nr_pages, iov_count, GFP_KERNEL);
+        bmd = bio_alloc_map_data(nr_pages, iov_count, gfp_mask);
         if (!bmd)
                 return ERR_PTR(-ENOMEM);
 
         ret = -ENOMEM;
-        bio = bio_alloc(GFP_KERNEL, nr_pages);
+        bio = bio_alloc(gfp_mask, nr_pages);
         if (!bio)
                 goto out_bmd;
 
         bio->bi_rw |= (!write_to_vm << BIO_RW);
 
         ret = 0;
+        i = 0;
         while (len) {
-                unsigned int bytes = PAGE_SIZE;
+                unsigned int bytes;
+
+                if (map_data)
+                        bytes = 1U << (PAGE_SHIFT + map_data->page_order);
+                else
+                        bytes = PAGE_SIZE;
 
                 if (bytes > len)
                         bytes = len;
 
-                page = alloc_page(q->bounce_gfp | GFP_KERNEL);
+                if (map_data) {
+                        if (i == map_data->nr_entries) {
+                                ret = -ENOMEM;
+                                break;
+                        }
+                        page = map_data->pages[i++];
+                } else
+                        page = alloc_page(q->bounce_gfp | gfp_mask);
                 if (!page) {
                         ret = -ENOMEM;
                         break;
@@ -634,16 +699,17 @@ struct bio *bio_copy_user_iov(struct request_queue *q, struct sg_iovec *iov,
          * success
          */
         if (!write_to_vm) {
-                ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0);
+                ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0, 0);
                 if (ret)
                         goto cleanup;
         }
 
-        bio_set_map_data(bmd, bio, iov, iov_count);
+        bio_set_map_data(bmd, bio, iov, iov_count, map_data ? 0 : 1);
         return bio;
 cleanup:
-        bio_for_each_segment(bvec, bio, i)
-                __free_page(bvec->bv_page);
+        if (!map_data)
+                bio_for_each_segment(bvec, bio, i)
+                        __free_page(bvec->bv_page);
 
         bio_put(bio);
 out_bmd:
@@ -654,29 +720,32 @@ out_bmd:
 /**
  *      bio_copy_user   -       copy user data to bio
  *      @q: destination block queue
+ *      @map_data: pointer to the rq_map_data holding pages (if necessary)
  *      @uaddr: start of user address
  *      @len: length in bytes
  *      @write_to_vm: bool indicating writing to pages or not
+ *      @gfp_mask: memory allocation flags
  *
  *      Prepares and returns a bio for indirect user io, bouncing data
  *      to/from kernel pages as necessary. Must be paired with
  *      call bio_uncopy_user() on io completion.
  */
-struct bio *bio_copy_user(struct request_queue *q, unsigned long uaddr,
-                          unsigned int len, int write_to_vm)
+struct bio *bio_copy_user(struct request_queue *q, struct rq_map_data *map_data,
+                          unsigned long uaddr, unsigned int len,
+                          int write_to_vm, gfp_t gfp_mask)
 {
         struct sg_iovec iov;
 
         iov.iov_base = (void __user *)uaddr;
         iov.iov_len = len;
 
-        return bio_copy_user_iov(q, &iov, 1, write_to_vm);
+        return bio_copy_user_iov(q, map_data, &iov, 1, write_to_vm, gfp_mask);
 }
 
 static struct bio *__bio_map_user_iov(struct request_queue *q,
                                       struct block_device *bdev,
                                       struct sg_iovec *iov, int iov_count,
-                                      int write_to_vm)
+                                      int write_to_vm, gfp_t gfp_mask)
 {
         int i, j;
         int nr_pages = 0;
@@ -702,12 +771,12 @@ static struct bio *__bio_map_user_iov(struct request_queue *q,
         if (!nr_pages)
                 return ERR_PTR(-EINVAL);
 
-        bio = bio_alloc(GFP_KERNEL, nr_pages);
+        bio = bio_alloc(gfp_mask, nr_pages);
         if (!bio)
                 return ERR_PTR(-ENOMEM);
 
         ret = -ENOMEM;
-        pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
+        pages = kcalloc(nr_pages, sizeof(struct page *), gfp_mask);
         if (!pages)
                 goto out;
 
@@ -786,19 +855,21 @@ static struct bio *__bio_map_user_iov(struct request_queue *q,
  *      @uaddr: start of user address
  *      @len: length in bytes
  *      @write_to_vm: bool indicating writing to pages or not
+ *      @gfp_mask: memory allocation flags
  *
  *      Map the user space address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
  */
 struct bio *bio_map_user(struct request_queue *q, struct block_device *bdev,
-                         unsigned long uaddr, unsigned int len, int write_to_vm)
+                         unsigned long uaddr, unsigned int len, int write_to_vm,
+                         gfp_t gfp_mask)
 {
         struct sg_iovec iov;
 
         iov.iov_base = (void __user *)uaddr;
         iov.iov_len = len;
 
-        return bio_map_user_iov(q, bdev, &iov, 1, write_to_vm);
+        return bio_map_user_iov(q, bdev, &iov, 1, write_to_vm, gfp_mask);
 }
 
 /**
@@ -808,18 +879,19 @@ struct bio *bio_map_user(struct request_queue *q, struct block_device *bdev,
  *      @iov:   the iovec.
  *      @iov_count: number of elements in the iovec
  *      @write_to_vm: bool indicating writing to pages or not
+ *      @gfp_mask: memory allocation flags
  *
  *      Map the user space address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
  */
 struct bio *bio_map_user_iov(struct request_queue *q, struct block_device *bdev,
                              struct sg_iovec *iov, int iov_count,
-                             int write_to_vm)
+                             int write_to_vm, gfp_t gfp_mask)
 {
         struct bio *bio;
 
-        bio = __bio_map_user_iov(q, bdev, iov, iov_count, write_to_vm);
-
+        bio = __bio_map_user_iov(q, bdev, iov, iov_count, write_to_vm,
+                                 gfp_mask);
         if (IS_ERR(bio))
                 return bio;
 
@@ -976,48 +1048,13 @@ static void bio_copy_kern_endio(struct bio *bio, int err)
 struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
                           gfp_t gfp_mask, int reading)
 {
-        unsigned long kaddr = (unsigned long)data;
-        unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        unsigned long start = kaddr >> PAGE_SHIFT;
-        const int nr_pages = end - start;
         struct bio *bio;
         struct bio_vec *bvec;
-        struct bio_map_data *bmd;
-        int i, ret;
-        struct sg_iovec iov;
-
-        iov.iov_base = data;
-        iov.iov_len = len;
-
-        bmd = bio_alloc_map_data(nr_pages, 1, gfp_mask);
-        if (!bmd)
-                return ERR_PTR(-ENOMEM);
-
-        ret = -ENOMEM;
-        bio = bio_alloc(gfp_mask, nr_pages);
-        if (!bio)
-                goto out_bmd;
-
-        while (len) {
-                struct page *page;
-                unsigned int bytes = PAGE_SIZE;
-
-                if (bytes > len)
-                        bytes = len;
-
-                page = alloc_page(q->bounce_gfp | gfp_mask);
-                if (!page) {
-                        ret = -ENOMEM;
-                        goto cleanup;
-                }
-
-                if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes) {
-                        ret = -EINVAL;
-                        goto cleanup;
-                }
+        int i;
 
-                len -= bytes;
-        }
+        bio = bio_copy_user(q, NULL, (unsigned long)data, len, 1, gfp_mask);
+        if (IS_ERR(bio))
+                return bio;
 
         if (!reading) {
                 void *p = data;
@@ -1030,20 +1067,9 @@ struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
                 }
         }
 
-        bio->bi_private = bmd;
         bio->bi_end_io = bio_copy_kern_endio;
 
-        bio_set_map_data(bmd, bio, &iov, 1);
         return bio;
-cleanup:
-        bio_for_each_segment(bvec, bio, i)
-                __free_page(bvec->bv_page);
-
-        bio_put(bio);
-out_bmd:
-        bio_free_map_data(bmd);
-
-        return ERR_PTR(ret);
 }
 
 /*
@@ -1230,9 +1256,9 @@ static void bio_pair_end_2(struct bio *bi, int err)
  * split a bio - only worry about a bio with a single page
  * in it's iovec
  */
-struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
+struct bio_pair *bio_split(struct bio *bi, int first_sectors)
 {
-        struct bio_pair *bp = mempool_alloc(pool, GFP_NOIO);
+        struct bio_pair *bp = mempool_alloc(bio_split_pool, GFP_NOIO);
 
         if (!bp)
                 return bp;
@@ -1266,7 +1292,7 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
         bp->bio2.bi_end_io = bio_pair_end_2;
 
         bp->bio1.bi_private = bi;
-        bp->bio2.bi_private = pool;
+        bp->bio2.bi_private = bio_split_pool;
 
         if (bio_integrity(bi))
                 bio_integrity_split(bi, bp, first_sectors);
@@ -1274,6 +1300,42 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
         return bp;
 }
 
+/**
+ *      bio_sector_offset - Find hardware sector offset in bio
+ *      @bio:           bio to inspect
+ *      @index:         bio_vec index
+ *      @offset:        offset in bv_page
+ *
+ *      Return the number of hardware sectors between beginning of bio
+ *      and an end point indicated by a bio_vec index and an offset
+ *      within that vector's page.
+ */
+sector_t bio_sector_offset(struct bio *bio, unsigned short index,
+                           unsigned int offset)
+{
+        unsigned int sector_sz = queue_hardsect_size(bio->bi_bdev->bd_disk->queue);
+        struct bio_vec *bv;
+        sector_t sectors;
+        int i;
+
+        sectors = 0;
+
+        if (index >= bio->bi_idx)
+                index = bio->bi_vcnt - 1;
+
+        __bio_for_each_segment(bv, bio, i, 0) {
+                if (i == index) {
+                        if (offset > bv->bv_offset)
+                                sectors += (offset - bv->bv_offset) / sector_sz;
+                        break;
+                }
+
+                sectors += bv->bv_len / sector_sz;
+        }
+
+        return sectors;
+}
+EXPORT_SYMBOL(bio_sector_offset);
 
 /*
  * create memory pools for biovec's in a bio_set.
@@ -1376,6 +1438,7 @@ static int __init init_bio(void)
 subsys_initcall(init_bio);
 
 EXPORT_SYMBOL(bio_alloc);
+EXPORT_SYMBOL(bio_kmalloc);
 EXPORT_SYMBOL(bio_put);
 EXPORT_SYMBOL(bio_free);
 EXPORT_SYMBOL(bio_endio);
@@ -1383,7 +1446,6 @@ EXPORT_SYMBOL(bio_init);
 EXPORT_SYMBOL(__bio_clone);
 EXPORT_SYMBOL(bio_clone);
 EXPORT_SYMBOL(bio_phys_segments);
-EXPORT_SYMBOL(bio_hw_segments);
 EXPORT_SYMBOL(bio_add_page);
 EXPORT_SYMBOL(bio_add_pc_page);
 EXPORT_SYMBOL(bio_get_nr_vecs);
@@ -1393,7 +1455,6 @@ EXPORT_SYMBOL(bio_map_kern);
 EXPORT_SYMBOL(bio_copy_kern);
 EXPORT_SYMBOL(bio_pair_release);
 EXPORT_SYMBOL(bio_split);
-EXPORT_SYMBOL(bio_split_pool);
 EXPORT_SYMBOL(bio_copy_user);
 EXPORT_SYMBOL(bio_uncopy_user);
 EXPORT_SYMBOL(bioset_create);
diff --git a/fs/block_dev.c b/fs/block_dev.c
index aff54219e049..d84f0469a016 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -540,22 +540,6 @@ EXPORT_SYMBOL(bd_release);
  *           /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
  */
 
-static struct kobject *bdev_get_kobj(struct block_device *bdev)
-{
-        if (bdev->bd_contains != bdev)
-                return kobject_get(&bdev->bd_part->dev.kobj);
-        else
-                return kobject_get(&bdev->bd_disk->dev.kobj);
-}
-
-static struct kobject *bdev_get_holder(struct block_device *bdev)
-{
-        if (bdev->bd_contains != bdev)
-                return kobject_get(bdev->bd_part->holder_dir);
-        else
-                return kobject_get(bdev->bd_disk->holder_dir);
-}
-
 static int add_symlink(struct kobject *from, struct kobject *to)
 {
         if (!from || !to)
@@ -604,11 +588,11 @@ static int bd_holder_grab_dirs(struct block_device *bdev,
         if (!bo->hdev)
                 goto fail_put_sdir;
 
-        bo->sdev = bdev_get_kobj(bdev);
+        bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
         if (!bo->sdev)
                 goto fail_put_hdev;
 
-        bo->hdir = bdev_get_holder(bdev);
+        bo->hdir = kobject_get(bdev->bd_part->holder_dir);
         if (!bo->hdir)
                 goto fail_put_sdev;
 
@@ -868,6 +852,87 @@ struct block_device *open_by_devnum(dev_t dev, unsigned mode)
 
 EXPORT_SYMBOL(open_by_devnum);
 
+/**
+ * flush_disk - invalidates all buffer-cache entries on a disk
+ *
+ * @bdev:      struct block device to be flushed
+ *
+ * Invalidates all buffer-cache entries on a disk. It should be called
+ * when a disk has been changed -- either by a media change or online
+ * resize.
+ */
+static void flush_disk(struct block_device *bdev)
+{
+        if (__invalidate_device(bdev)) {
+                char name[BDEVNAME_SIZE] = "";
+
+                if (bdev->bd_disk)
+                        disk_name(bdev->bd_disk, 0, name);
+                printk(KERN_WARNING "VFS: busy inodes on changed media or "
+                       "resized disk %s\n", name);
+        }
+
+        if (!bdev->bd_disk)
+                return;
+        if (disk_partitionable(bdev->bd_disk))
+                bdev->bd_invalidated = 1;
+}
+
+/**
+ * check_disk_size_change - checks for disk size change and adjusts bdev size.
+ * @disk: struct gendisk to check
+ * @bdev: struct bdev to adjust.
+ *
+ * This routine checks to see if the bdev size does not match the disk size
+ * and adjusts it if it differs.
+ */
+void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
+{
+        loff_t disk_size, bdev_size;
+
+        disk_size = (loff_t)get_capacity(disk) << 9;
+        bdev_size = i_size_read(bdev->bd_inode);
+        if (disk_size != bdev_size) {
+                char name[BDEVNAME_SIZE];
+
+                disk_name(disk, 0, name);
+                printk(KERN_INFO
+                       "%s: detected capacity change from %lld to %lld\n",
+                       name, bdev_size, disk_size);
+                i_size_write(bdev->bd_inode, disk_size);
+                flush_disk(bdev);
+        }
+}
+EXPORT_SYMBOL(check_disk_size_change);
+
+/**
+ * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
+ * @disk: struct gendisk to be revalidated
+ *
+ * This routine is a wrapper for lower-level driver's revalidate_disk
+ * call-backs.  It is used to do common pre and post operations needed
+ * for all revalidate_disk operations.
+ */
+int revalidate_disk(struct gendisk *disk)
+{
+        struct block_device *bdev;
+        int ret = 0;
+
+        if (disk->fops->revalidate_disk)
+                ret = disk->fops->revalidate_disk(disk);
+
+        bdev = bdget_disk(disk, 0);
+        if (!bdev)
+                return ret;
+
+        mutex_lock(&bdev->bd_mutex);
+        check_disk_size_change(disk, bdev);
+        mutex_unlock(&bdev->bd_mutex);
+        bdput(bdev);
+        return ret;
+}
+EXPORT_SYMBOL(revalidate_disk);
+
 /*
  * This routine checks whether a removable media has been changed,
  * and invalidates all buffer-cache-entries in that case. This
@@ -887,13 +952,9 @@ int check_disk_change(struct block_device *bdev)
         if (!bdops->media_changed(bdev->bd_disk))
                 return 0;
 
-        if (__invalidate_device(bdev))
-                printk("VFS: busy inodes on changed media.\n");
-
+        flush_disk(bdev);
         if (bdops->revalidate_disk)
                 bdops->revalidate_disk(bdev->bd_disk);
-        if (bdev->bd_disk->minors > 1)
-                bdev->bd_invalidated = 1;
         return 1;
 }
 
@@ -927,10 +988,10 @@ static int __blkdev_put(struct block_device *bdev, int for_part);
 
 static int do_open(struct block_device *bdev, struct file *file, int for_part)
 {
-        struct module *owner = NULL;
         struct gendisk *disk;
+        struct hd_struct *part = NULL;
         int ret;
-        int part;
+        int partno;
         int perm = 0;
 
         if (file->f_mode & FMODE_READ)
@@ -948,25 +1009,27 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
 
         ret = -ENXIO;
         file->f_mapping = bdev->bd_inode->i_mapping;
+
         lock_kernel();
-        disk = get_gendisk(bdev->bd_dev, &part);
-        if (!disk) {
-                unlock_kernel();
-                bdput(bdev);
-                return ret;
-        }
-        owner = disk->fops->owner;
+
+        disk = get_gendisk(bdev->bd_dev, &partno);
+        if (!disk)
+                goto out_unlock_kernel;
+        part = disk_get_part(disk, partno);
+        if (!part)
+                goto out_unlock_kernel;
 
         mutex_lock_nested(&bdev->bd_mutex, for_part);
         if (!bdev->bd_openers) {
                 bdev->bd_disk = disk;
+                bdev->bd_part = part;
                 bdev->bd_contains = bdev;
-                if (!part) {
+                if (!partno) {
                         struct backing_dev_info *bdi;
                         if (disk->fops->open) {
                                 ret = disk->fops->open(bdev->bd_inode, file);
                                 if (ret)
-                                        goto out_first;
+                                        goto out_clear;
                         }
                         if (!bdev->bd_openers) {
                                 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
@@ -978,36 +1041,36 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
                         if (bdev->bd_invalidated)
                                 rescan_partitions(disk, bdev);
                 } else {
-                        struct hd_struct *p;
                         struct block_device *whole;
                         whole = bdget_disk(disk, 0);
                         ret = -ENOMEM;
                         if (!whole)
-                                goto out_first;
+                                goto out_clear;
                         BUG_ON(for_part);
                         ret = __blkdev_get(whole, file->f_mode, file->f_flags, 1);
                         if (ret)
-                                goto out_first;
+                                goto out_clear;
                         bdev->bd_contains = whole;
-                        p = disk->part[part - 1];
                         bdev->bd_inode->i_data.backing_dev_info =
                            whole->bd_inode->i_data.backing_dev_info;
-                        if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {
+                        if (!(disk->flags & GENHD_FL_UP) ||
+                            !part || !part->nr_sects) {
                                 ret = -ENXIO;
-                                goto out_first;
+                                goto out_clear;
                         }
-                        kobject_get(&p->dev.kobj);
-                        bdev->bd_part = p;
-                        bd_set_size(bdev, (loff_t) p->nr_sects << 9);
+                        bd_set_size(bdev, (loff_t)part->nr_sects << 9);
                 }
         } else {
+                disk_put_part(part);
                 put_disk(disk);
-                module_put(owner);
+                module_put(disk->fops->owner);
+                part = NULL;
+                disk = NULL;
                 if (bdev->bd_contains == bdev) {
                         if (bdev->bd_disk->fops->open) {
                                 ret = bdev->bd_disk->fops->open(bdev->bd_inode, file);
                                 if (ret)
-                                        goto out;
+                                        goto out_unlock_bdev;
                         }
                         if (bdev->bd_invalidated)
                                 rescan_partitions(bdev->bd_disk, bdev);
@@ -1020,19 +1083,24 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
         unlock_kernel();
         return 0;
 
-out_first:
+ out_clear:
         bdev->bd_disk = NULL;
+        bdev->bd_part = NULL;
         bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
         if (bdev != bdev->bd_contains)
                 __blkdev_put(bdev->bd_contains, 1);
         bdev->bd_contains = NULL;
-        put_disk(disk);
-        module_put(owner);
-out:
+ out_unlock_bdev:
         mutex_unlock(&bdev->bd_mutex);
+ out_unlock_kernel:
         unlock_kernel();
-        if (ret)
-                bdput(bdev);
+
+        disk_put_part(part);
+        if (disk)
+                module_put(disk->fops->owner);
+        put_disk(disk);
+        bdput(bdev);
+
         return ret;
 }
 
@@ -1117,11 +1185,8 @@ static int __blkdev_put(struct block_device *bdev, int for_part)
 
                 put_disk(disk);
                 module_put(owner);
-
-                if (bdev->bd_contains != bdev) {
-                        kobject_put(&bdev->bd_part->dev.kobj);
-                        bdev->bd_part = NULL;
-                }
+                disk_put_part(bdev->bd_part);
+                bdev->bd_part = NULL;
                 bdev->bd_disk = NULL;
                 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
                 if (bdev != bdev->bd_contains)
@@ -1197,10 +1262,9 @@ EXPORT_SYMBOL(ioctl_by_bdev);
 
 /**
  * lookup_bdev  - lookup a struct block_device by name
+ * @pathname:   special file representing the block device
  *
- * @path:       special file representing the block device
- *
- * Get a reference to the blockdevice at @path in the current
+ * Get a reference to the blockdevice at @pathname in the current
  * namespace if possible and return it.  Return ERR_PTR(error)
  * otherwise.
  */
diff --git a/fs/fat/fatent.c b/fs/fat/fatent.c
index 302e95c4af7e..fb98b3d847ed 100644
--- a/fs/fat/fatent.c
+++ b/fs/fat/fatent.c
@@ -6,6 +6,7 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/msdos_fs.h>
+#include <linux/blkdev.h>
 
 struct fatent_operations {
         void (*ent_blocknr)(struct super_block *, int, int *, sector_t *);
@@ -535,6 +536,7 @@ int fat_free_clusters(struct inode *inode, int cluster)
         struct fat_entry fatent;
         struct buffer_head *bhs[MAX_BUF_PER_PAGE];
         int i, err, nr_bhs;
+        int first_cl = cluster;
 
         nr_bhs = 0;
         fatent_init(&fatent);
@@ -551,6 +553,18 @@ int fat_free_clusters(struct inode *inode, int cluster)
                         goto error;
                 }
 
+                /* 
+                 * Issue discard for the sectors we no longer care about,
+                 * batching contiguous clusters into one request
+                 */
+                if (cluster != fatent.entry + 1) {
+                        int nr_clus = fatent.entry - first_cl + 1;
+
+                        sb_issue_discard(sb, fat_clus_to_blknr(sbi, first_cl),
+                                         nr_clus * sbi->sec_per_clus);
+                        first_cl = cluster;
+                }
+
                 ops->ent_put(&fatent, FAT_ENT_FREE);
                 if (sbi->free_clusters != -1) {
                         sbi->free_clusters++;
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index ecc3330972e5..7408227c49c9 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -120,22 +120,21 @@ static int (*check_part[])(struct parsed_partitions *, struct block_device *) =
  * a pointer to that same buffer (for convenience).
  */
 
-char *disk_name(struct gendisk *hd, int part, char *buf)
+char *disk_name(struct gendisk *hd, int partno, char *buf)
 {
-        if (!part)
+        if (!partno)
                 snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
         else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
-                snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, part);
+                snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
         else
-                snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, part);
+                snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
 
         return buf;
 }
 
 const char *bdevname(struct block_device *bdev, char *buf)
 {
-        int part = MINOR(bdev->bd_dev) - bdev->bd_disk->first_minor;
-        return disk_name(bdev->bd_disk, part, buf);
+        return disk_name(bdev->bd_disk, bdev->bd_part->partno, buf);
 }
 
 EXPORT_SYMBOL(bdevname);
@@ -169,7 +168,7 @@ check_partition(struct gendisk *hd, struct block_device *bdev)
         if (isdigit(state->name[strlen(state->name)-1]))
                 sprintf(state->name, "p");
 
-        state->limit = hd->minors;
+        state->limit = disk_max_parts(hd);
         i = res = err = 0;
         while (!res && check_part[i]) {
                 memset(&state->parts, 0, sizeof(state->parts));
@@ -204,21 +203,22 @@ static ssize_t part_start_show(struct device *dev,
         return sprintf(buf, "%llu\n",(unsigned long long)p->start_sect);
 }
 
-static ssize_t part_size_show(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+ssize_t part_size_show(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
         struct hd_struct *p = dev_to_part(dev);
         return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects);
 }
 
-static ssize_t part_stat_show(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+ssize_t part_stat_show(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
         struct hd_struct *p = dev_to_part(dev);
+        int cpu;
 
-        preempt_disable();
-        part_round_stats(p);
-        preempt_enable();
+        cpu = part_stat_lock();
+        part_round_stats(cpu, p);
+        part_stat_unlock();
         return sprintf(buf,
                 "%8lu %8lu %8llu %8u "
                 "%8lu %8lu %8llu %8u "
@@ -238,17 +238,17 @@ static ssize_t part_stat_show(struct device *dev,
 }
 
 #ifdef CONFIG_FAIL_MAKE_REQUEST
-static ssize_t part_fail_show(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+ssize_t part_fail_show(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
         struct hd_struct *p = dev_to_part(dev);
 
         return sprintf(buf, "%d\n", p->make_it_fail);
 }
 
-static ssize_t part_fail_store(struct device *dev,
-                               struct device_attribute *attr,
-                               const char *buf, size_t count)
+ssize_t part_fail_store(struct device *dev,
+                        struct device_attribute *attr,
+                        const char *buf, size_t count)
 {
         struct hd_struct *p = dev_to_part(dev);
         int i;
@@ -300,40 +300,34 @@ struct device_type part_type = {
         .release        = part_release,
 };
 
-static inline void partition_sysfs_add_subdir(struct hd_struct *p)
-{
-        struct kobject *k;
-
-        k = kobject_get(&p->dev.kobj);
-        p->holder_dir = kobject_create_and_add("holders", k);
-        kobject_put(k);
-}
-
-static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
+static void delete_partition_rcu_cb(struct rcu_head *head)
 {
-        struct kobject *k;
+        struct hd_struct *part = container_of(head, struct hd_struct, rcu_head);
 
-        k = kobject_get(&disk->dev.kobj);
-        disk->holder_dir = kobject_create_and_add("holders", k);
-        disk->slave_dir = kobject_create_and_add("slaves", k);
-        kobject_put(k);
+        part->start_sect = 0;
+        part->nr_sects = 0;
+        part_stat_set_all(part, 0);
+        put_device(part_to_dev(part));
 }
 
-void delete_partition(struct gendisk *disk, int part)
+void delete_partition(struct gendisk *disk, int partno)
 {
-        struct hd_struct *p = disk->part[part-1];
+        struct disk_part_tbl *ptbl = disk->part_tbl;
+        struct hd_struct *part;
 
-        if (!p)
+        if (partno >= ptbl->len)
                 return;
-        if (!p->nr_sects)
+
+        part = ptbl->part[partno];
+        if (!part)
                 return;
-        disk->part[part-1] = NULL;
-        p->start_sect = 0;
-        p->nr_sects = 0;
-        part_stat_set_all(p, 0);
-        kobject_put(p->holder_dir);
-        device_del(&p->dev);
-        put_device(&p->dev);
+
+        blk_free_devt(part_devt(part));
+        rcu_assign_pointer(ptbl->part[partno], NULL);
+        kobject_put(part->holder_dir);
+        device_del(part_to_dev(part));
+
+        call_rcu(&part->rcu_head, delete_partition_rcu_cb);
 }
 
 static ssize_t whole_disk_show(struct device *dev,
@@ -344,102 +338,132 @@ static ssize_t whole_disk_show(struct device *dev,
 static DEVICE_ATTR(whole_disk, S_IRUSR | S_IRGRP | S_IROTH,
                    whole_disk_show, NULL);
 
-int add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)
+int add_partition(struct gendisk *disk, int partno,
+                  sector_t start, sector_t len, int flags)
 {
         struct hd_struct *p;
+        dev_t devt = MKDEV(0, 0);
+        struct device *ddev = disk_to_dev(disk);
+        struct device *pdev;
+        struct disk_part_tbl *ptbl;
+        const char *dname;
         int err;
 
+        err = disk_expand_part_tbl(disk, partno);
+        if (err)
+                return err;
+        ptbl = disk->part_tbl;
+
+        if (ptbl->part[partno])
+                return -EBUSY;
+
         p = kzalloc(sizeof(*p), GFP_KERNEL);
         if (!p)
                 return -ENOMEM;
 
         if (!init_part_stats(p)) {
                 err = -ENOMEM;
-                goto out0;
+                goto out_free;
         }
+        pdev = part_to_dev(p);
+
         p->start_sect = start;
         p->nr_sects = len;
-        p->partno = part;
-        p->policy = disk->policy;
+        p->partno = partno;
+        p->policy = get_disk_ro(disk);
 
-        if (isdigit(disk->dev.bus_id[strlen(disk->dev.bus_id)-1]))
-                snprintf(p->dev.bus_id, BUS_ID_SIZE,
-                "%sp%d", disk->dev.bus_id, part);
+        dname = dev_name(ddev);
+        if (isdigit(dname[strlen(dname) - 1]))
+                snprintf(pdev->bus_id, BUS_ID_SIZE, "%sp%d", dname, partno);
         else
-                snprintf(p->dev.bus_id, BUS_ID_SIZE,
-                         "%s%d", disk->dev.bus_id, part);
+                snprintf(pdev->bus_id, BUS_ID_SIZE, "%s%d", dname, partno);
 
-        device_initialize(&p->dev);
-        p->dev.devt = MKDEV(disk->major, disk->first_minor + part);
-        p->dev.class = &block_class;
-        p->dev.type = &part_type;
-        p->dev.parent = &disk->dev;
-        disk->part[part-1] = p;
+        device_initialize(pdev);
+        pdev->class = &block_class;
+        pdev->type = &part_type;
+        pdev->parent = ddev;
+
+        err = blk_alloc_devt(p, &devt);
+        if (err)
+                goto out_free;
+        pdev->devt = devt;
 
         /* delay uevent until 'holders' subdir is created */
-        p->dev.uevent_suppress = 1;
-        err = device_add(&p->dev);
+        pdev->uevent_suppress = 1;
+        err = device_add(pdev);
         if (err)
-                goto out1;
-        partition_sysfs_add_subdir(p);
-        p->dev.uevent_suppress = 0;
+                goto out_put;
+
+        err = -ENOMEM;
+        p->holder_dir = kobject_create_and_add("holders", &pdev->kobj);
+        if (!p->holder_dir)
+                goto out_del;
+
+        pdev->uevent_suppress = 0;
         if (flags & ADDPART_FLAG_WHOLEDISK) {
-                err = device_create_file(&p->dev, &dev_attr_whole_disk);
+                err = device_create_file(pdev, &dev_attr_whole_disk);
                 if (err)
-                        goto out2;
+                        goto out_del;
         }
 
+        /* everything is up and running, commence */
+        INIT_RCU_HEAD(&p->rcu_head);
+        rcu_assign_pointer(ptbl->part[partno], p);
+
         /* suppress uevent if the disk supresses it */
-        if (!disk->dev.uevent_suppress)
-                kobject_uevent(&p->dev.kobj, KOBJ_ADD);
+        if (!ddev->uevent_suppress)
+                kobject_uevent(&pdev->kobj, KOBJ_ADD);
 
         return 0;
 
-out2:
-        device_del(&p->dev);
-out1:
-        put_device(&p->dev);
-        free_part_stats(p);
-out0:
+out_free:
         kfree(p);
         return err;
+out_del:
+        kobject_put(p->holder_dir);
+        device_del(pdev);
+out_put:
+        put_device(pdev);
+        blk_free_devt(devt);
+        return err;
 }
 
 /* Not exported, helper to add_disk(). */
 void register_disk(struct gendisk *disk)
 {
+        struct device *ddev = disk_to_dev(disk);
         struct block_device *bdev;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
         char *s;
-        int i;
-        struct hd_struct *p;
         int err;
 
-        disk->dev.parent = disk->driverfs_dev;
-        disk->dev.devt = MKDEV(disk->major, disk->first_minor);
+        ddev->parent = disk->driverfs_dev;
 
-        strlcpy(disk->dev.bus_id, disk->disk_name, BUS_ID_SIZE);
+        strlcpy(ddev->bus_id, disk->disk_name, BUS_ID_SIZE);
         /* ewww... some of these buggers have / in the name... */
-        s = strchr(disk->dev.bus_id, '/');
+        s = strchr(ddev->bus_id, '/');
         if (s)
                 *s = '!';
 
         /* delay uevents, until we scanned partition table */
-        disk->dev.uevent_suppress = 1;
+        ddev->uevent_suppress = 1;
 
-        if (device_add(&disk->dev))
+        if (device_add(ddev))
                 return;
 #ifndef CONFIG_SYSFS_DEPRECATED
-        err = sysfs_create_link(block_depr, &disk->dev.kobj,
-                                kobject_name(&disk->dev.kobj));
+        err = sysfs_create_link(block_depr, &ddev->kobj,
+                                kobject_name(&ddev->kobj));
         if (err) {
-                device_del(&disk->dev);
+                device_del(ddev);
                 return;
         }
 #endif
-        disk_sysfs_add_subdirs(disk);
+        disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
+        disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
 
         /* No minors to use for partitions */
-        if (disk->minors == 1)
+        if (!disk_partitionable(disk))
                 goto exit;
 
         /* No such device (e.g., media were just removed) */
@@ -458,41 +482,57 @@ void register_disk(struct gendisk *disk)
 
 exit:
         /* announce disk after possible partitions are created */
-        disk->dev.uevent_suppress = 0;
-        kobject_uevent(&disk->dev.kobj, KOBJ_ADD);
+        ddev->uevent_suppress = 0;
+        kobject_uevent(&ddev->kobj, KOBJ_ADD);
 
         /* announce possible partitions */
-        for (i = 1; i < disk->minors; i++) {
-                p = disk->part[i-1];
-                if (!p || !p->nr_sects)
-                        continue;
-                kobject_uevent(&p->dev.kobj, KOBJ_ADD);
-        }
+        disk_part_iter_init(&piter, disk, 0);
+        while ((part = disk_part_iter_next(&piter)))
+                kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
+        disk_part_iter_exit(&piter);
 }
 
 int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
 {
+        struct disk_part_iter piter;
+        struct hd_struct *part;
         struct parsed_partitions *state;
-        int p, res;
+        int p, highest, res;
 
         if (bdev->bd_part_count)
                 return -EBUSY;
         res = invalidate_partition(disk, 0);
         if (res)
                 return res;
-        bdev->bd_invalidated = 0;
-        for (p = 1; p < disk->minors; p++)
-                delete_partition(disk, p);
+
+        disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
+        while ((part = disk_part_iter_next(&piter)))
+                delete_partition(disk, part->partno);
+        disk_part_iter_exit(&piter);
+
         if (disk->fops->revalidate_disk)
                 disk->fops->revalidate_disk(disk);
+        check_disk_size_change(disk, bdev);
+        bdev->bd_invalidated = 0;
         if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
                 return 0;
         if (IS_ERR(state))      /* I/O error reading the partition table */
                 return -EIO;
 
         /* tell userspace that the media / partition table may have changed */
-        kobject_uevent(&disk->dev.kobj, KOBJ_CHANGE);
+        kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
 
+        /* Detect the highest partition number and preallocate
+         * disk->part_tbl.  This is an optimization and not strictly
+         * necessary.
+         */
+        for (p = 1, highest = 0; p < state->limit; p++)
+                if (state->parts[p].size)
+                        highest = p;
+
+        disk_expand_part_tbl(disk, highest);
+
+        /* add partitions */
         for (p = 1; p < state->limit; p++) {
                 sector_t size = state->parts[p].size;
                 sector_t from = state->parts[p].from;
@@ -541,25 +581,31 @@ EXPORT_SYMBOL(read_dev_sector);
 
 void del_gendisk(struct gendisk *disk)
 {
-        int p;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
 
         /* invalidate stuff */
-        for (p = disk->minors - 1; p > 0; p--) {
-                invalidate_partition(disk, p);
-                delete_partition(disk, p);
+        disk_part_iter_init(&piter, disk,
+                             DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
+        while ((part = disk_part_iter_next(&piter))) {
+                invalidate_partition(disk, part->partno);
+                delete_partition(disk, part->partno);
         }
+        disk_part_iter_exit(&piter);
+
         invalidate_partition(disk, 0);
-        disk->capacity = 0;
+        blk_free_devt(disk_to_dev(disk)->devt);
+        set_capacity(disk, 0);
         disk->flags &= ~GENHD_FL_UP;
         unlink_gendisk(disk);
-        disk_stat_set_all(disk, 0);
-        disk->stamp = 0;
+        part_stat_set_all(&disk->part0, 0);
+        disk->part0.stamp = 0;
 
-        kobject_put(disk->holder_dir);
+        kobject_put(disk->part0.holder_dir);
         kobject_put(disk->slave_dir);
         disk->driverfs_dev = NULL;
 #ifndef CONFIG_SYSFS_DEPRECATED
-        sysfs_remove_link(block_depr, disk->dev.bus_id);
+        sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
 #endif
-        device_del(&disk->dev);
+        device_del(disk_to_dev(disk));
 }
diff --git a/fs/partitions/check.h b/fs/partitions/check.h
index 17ae8ecd9e8b..98dbe1a84528 100644
--- a/fs/partitions/check.h
+++ b/fs/partitions/check.h
@@ -5,15 +5,13 @@
  * add_gd_partition adds a partitions details to the devices partition
  * description.
  */
-enum { MAX_PART = 256 };
-
 struct parsed_partitions {
         char name[BDEVNAME_SIZE];
         struct {
                 sector_t from;
                 sector_t size;
                 int flags;
-        } parts[MAX_PART];
+        } parts[DISK_MAX_PARTS];
         int next;
         int limit;
 };