Merge branch 'ovl-fixes' into for-linus

8 files changed, 36 insertions, 29 deletions

diff --git a/block/bio.c b/block/bio.c
index f124a0a624fc..807d25e466ec 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -1339,7 +1339,7 @@ struct bio *bio_map_user_iov(struct request_queue *q,
                  * release the pages we didn't map into the bio, if any
                  */
                 while (j < page_limit)
-                        page_cache_release(pages[j++]);
+                        put_page(pages[j++]);
         }
 
         kfree(pages);
@@ -1365,7 +1365,7 @@ struct bio *bio_map_user_iov(struct request_queue *q,
         for (j = 0; j < nr_pages; j++) {
                 if (!pages[j])
                         break;
-                page_cache_release(pages[j]);
+                put_page(pages[j]);
         }
  out:
         kfree(pages);
@@ -1385,7 +1385,7 @@ static void __bio_unmap_user(struct bio *bio)
                 if (bio_data_dir(bio) == READ)
                         set_page_dirty_lock(bvec->bv_page);
 
-                page_cache_release(bvec->bv_page);
+                put_page(bvec->bv_page);
         }
 
         bio_put(bio);
@@ -1615,8 +1615,8 @@ static void bio_release_pages(struct bio *bio)
  * the BIO and the offending pages and re-dirty the pages in process context.
  *
  * It is expected that bio_check_pages_dirty() will wholly own the BIO from
- * here on.  It will run one page_cache_release() against each page and will
- * run one bio_put() against the BIO.
+ * here on.  It will run one put_page() against each page and will run one
+ * bio_put() against the BIO.
  */
 
 static void bio_dirty_fn(struct work_struct *work);
@@ -1658,7 +1658,7 @@ void bio_check_pages_dirty(struct bio *bio)
                 struct page *page = bvec->bv_page;
 
                 if (PageDirty(page) || PageCompound(page)) {
-                        page_cache_release(page);
+                        put_page(page);
                         bvec->bv_page = NULL;
                 } else {
                         nr_clean_pages++;
diff --git a/block/blk-core.c b/block/blk-core.c
index 827f8badd143..b60537b2c35b 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -706,7 +706,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
                 goto fail_id;
 
         q->backing_dev_info.ra_pages =
-                        (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
+                        (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
         q->backing_dev_info.capabilities = BDI_CAP_CGROUP_WRITEBACK;
         q->backing_dev_info.name = "block";
         q->node = node_id;
diff --git a/block/blk-settings.c b/block/blk-settings.c
index c7bb666aafd1..331e4eee0dda 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -239,8 +239,8 @@ void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_secto
         struct queue_limits *limits = &q->limits;
         unsigned int max_sectors;
 
-        if ((max_hw_sectors << 9) < PAGE_CACHE_SIZE) {
-                max_hw_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
+        if ((max_hw_sectors << 9) < PAGE_SIZE) {
+                max_hw_sectors = 1 << (PAGE_SHIFT - 9);
                 printk(KERN_INFO "%s: set to minimum %d\n",
                        __func__, max_hw_sectors);
         }
@@ -329,8 +329,8 @@ EXPORT_SYMBOL(blk_queue_max_segments);
  **/
 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
 {
-        if (max_size < PAGE_CACHE_SIZE) {
-                max_size = PAGE_CACHE_SIZE;
+        if (max_size < PAGE_SIZE) {
+                max_size = PAGE_SIZE;
                 printk(KERN_INFO "%s: set to minimum %d\n",
                        __func__, max_size);
         }
@@ -760,8 +760,8 @@ EXPORT_SYMBOL_GPL(blk_queue_dma_drain);
  **/
 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
 {
-        if (mask < PAGE_CACHE_SIZE - 1) {
-                mask = PAGE_CACHE_SIZE - 1;
+        if (mask < PAGE_SIZE - 1) {
+                mask = PAGE_SIZE - 1;
                 printk(KERN_INFO "%s: set to minimum %lx\n",
                        __func__, mask);
         }
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index dd93763057ce..995b58d46ed1 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -76,7 +76,7 @@ queue_requests_store(struct request_queue *q, const char *page, size_t count)
 static ssize_t queue_ra_show(struct request_queue *q, char *page)
 {
         unsigned long ra_kb = q->backing_dev_info.ra_pages <<
-                                        (PAGE_CACHE_SHIFT - 10);
+                                        (PAGE_SHIFT - 10);
 
         return queue_var_show(ra_kb, (page));
 }
@@ -90,7 +90,7 @@ queue_ra_store(struct request_queue *q, const char *page, size_t count)
         if (ret < 0)
                 return ret;
 
-        q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10);
+        q->backing_dev_info.ra_pages = ra_kb >> (PAGE_SHIFT - 10);
 
         return ret;
 }
@@ -117,7 +117,7 @@ static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
         if (blk_queue_cluster(q))
                 return queue_var_show(queue_max_segment_size(q), (page));
 
-        return queue_var_show(PAGE_CACHE_SIZE, (page));
+        return queue_var_show(PAGE_SIZE, (page));
 }
 
 static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
@@ -198,7 +198,7 @@ queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
 {
         unsigned long max_sectors_kb,
                 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
-                        page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
+                        page_kb = 1 << (PAGE_SHIFT - 10);
         ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
 
         if (ret < 0)
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index e3c591dd8f19..4a349787bc62 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -4075,7 +4075,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
                  * idle timer unplug to continue working.
                  */
                 if (cfq_cfqq_wait_request(cfqq)) {
-                        if (blk_rq_bytes(rq) > PAGE_CACHE_SIZE ||
+                        if (blk_rq_bytes(rq) > PAGE_SIZE ||
                             cfqd->busy_queues > 1) {
                                 cfq_del_timer(cfqd, cfqq);
                                 cfq_clear_cfqq_wait_request(cfqq);
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index f678c733df40..556826ac7cb4 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -710,7 +710,7 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                         return -EINVAL;
                 bdi = blk_get_backing_dev_info(bdev);
                 return compat_put_long(arg,
-                                       (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
+                                       (bdi->ra_pages * PAGE_SIZE) / 512);
         case BLKROGET: /* compatible */
                 return compat_put_int(arg, bdev_read_only(bdev) != 0);
         case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
@@ -729,7 +729,7 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                 if (!capable(CAP_SYS_ADMIN))
                         return -EACCES;
                 bdi = blk_get_backing_dev_info(bdev);
-                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
+                bdi->ra_pages = (arg * 512) / PAGE_SIZE;
                 return 0;
         case BLKGETSIZE:
                 size = i_size_read(bdev->bd_inode);
diff --git a/block/ioctl.c b/block/ioctl.c
index d8996bbd7f12..4ff1f92f89ca 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -550,7 +550,7 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                 if (!arg)
                         return -EINVAL;
                 bdi = blk_get_backing_dev_info(bdev);
-                return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
+                return put_long(arg, (bdi->ra_pages * PAGE_SIZE) / 512);
         case BLKROGET:
                 return put_int(arg, bdev_read_only(bdev) != 0);
         case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */
@@ -578,7 +578,7 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                 if(!capable(CAP_SYS_ADMIN))
                         return -EACCES;
                 bdi = blk_get_backing_dev_info(bdev);
-                bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
+                bdi->ra_pages = (arg * 512) / PAGE_SIZE;
                 return 0;
         case BLKBSZSET:
                 return blkdev_bszset(bdev, mode, argp);
diff --git a/block/partition-generic.c b/block/partition-generic.c
index 5d8701941054..d7eb77e1e3a8 100644
--- a/block/partition-generic.c
+++ b/block/partition-generic.c
@@ -361,15 +361,20 @@ struct hd_struct *add_partition(struct gendisk *disk, int partno,
                         goto out_del;
         }
 
+        err = hd_ref_init(p);
+        if (err) {
+                if (flags & ADDPART_FLAG_WHOLEDISK)
+                        goto out_remove_file;
+                goto out_del;
+        }
+
         /* everything is up and running, commence */
         rcu_assign_pointer(ptbl->part[partno], p);
 
         /* suppress uevent if the disk suppresses it */
         if (!dev_get_uevent_suppress(ddev))
                 kobject_uevent(&pdev->kobj, KOBJ_ADD);
-
-        if (!hd_ref_init(p))
-                return p;
+        return p;
 
 out_free_info:
         free_part_info(p);
@@ -378,6 +383,8 @@ out_free_stats:
 out_free:
         kfree(p);
         return ERR_PTR(err);
+out_remove_file:
+        device_remove_file(pdev, &dev_attr_whole_disk);
 out_del:
         kobject_put(p->holder_dir);
         device_del(pdev);
@@ -566,8 +573,8 @@ static struct page *read_pagecache_sector(struct block_device *bdev, sector_t n)
 {
         struct address_space *mapping = bdev->bd_inode->i_mapping;
 
-        return read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
-                        NULL);
+        return read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_SHIFT-9)),
+                                 NULL);
 }
 
 unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
@@ -584,9 +591,9 @@ unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
                 if (PageError(page))
                         goto fail;
                 p->v = page;
-                return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
+                return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_SHIFT - 9)) - 1)) << 9);
 fail:
-                page_cache_release(page);
+                put_page(page);
         }
         p->v = NULL;
         return NULL;