Merge branch 'master' into next

Conflicts:
	fs/nfsd/nfs4recover.c

Manually fixed above to use new creds API functions, e.g.
nfs4_save_creds().

Signed-off-by: James Morris <jmorris@namei.org>

7 files changed, 43 insertions, 17 deletions

diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 5c99ff8d2db8..6e72d661ae42 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -161,7 +161,7 @@ static inline struct request *start_ordered(struct request_queue *q,
         /*
          * Prep proxy barrier request.
          */
-        blkdev_dequeue_request(rq);
+        elv_dequeue_request(q, rq);
         q->orig_bar_rq = rq;
         rq = &q->bar_rq;
         blk_rq_init(q, rq);
@@ -219,7 +219,7 @@ int blk_do_ordered(struct request_queue *q, struct request **rqp)
                          * This can happen when the queue switches to
                          * ORDERED_NONE while this request is on it.
                          */
-                        blkdev_dequeue_request(rq);
+                        elv_dequeue_request(q, rq);
                         if (__blk_end_request(rq, -EOPNOTSUPP,
                                               blk_rq_bytes(rq)))
                                 BUG();
diff --git a/block/blk-core.c b/block/blk-core.c
index 10e8a64a5a5b..c36aa98fafa3 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -592,7 +592,7 @@ blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
                                    1 << QUEUE_FLAG_STACKABLE);
         q->queue_lock           = lock;
 
-        blk_queue_segment_boundary(q, 0xffffffff);
+        blk_queue_segment_boundary(q, BLK_SEG_BOUNDARY_MASK);
 
         blk_queue_make_request(q, __make_request);
         blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);
@@ -1637,6 +1637,28 @@ int blk_insert_cloned_request(struct request_queue *q, struct request *rq)
 EXPORT_SYMBOL_GPL(blk_insert_cloned_request);
 
 /**
+ * blkdev_dequeue_request - dequeue request and start timeout timer
+ * @req: request to dequeue
+ *
+ * Dequeue @req and start timeout timer on it.  This hands off the
+ * request to the driver.
+ *
+ * Block internal functions which don't want to start timer should
+ * call elv_dequeue_request().
+ */
+void blkdev_dequeue_request(struct request *req)
+{
+        elv_dequeue_request(req->q, req);
+
+        /*
+         * We are now handing the request to the hardware, add the
+         * timeout handler.
+         */
+        blk_add_timer(req);
+}
+EXPORT_SYMBOL(blkdev_dequeue_request);
+
+/**
  * __end_that_request_first - end I/O on a request
  * @req:      the request being processed
  * @error:    %0 for success, < %0 for error
@@ -1774,7 +1796,7 @@ static void end_that_request_last(struct request *req, int error)
                 blk_queue_end_tag(req->q, req);
 
         if (blk_queued_rq(req))
-                blkdev_dequeue_request(req);
+                elv_dequeue_request(req->q, req);
 
         if (unlikely(laptop_mode) && blk_fs_request(req))
                 laptop_io_completion();
diff --git a/block/blk-map.c b/block/blk-map.c
index 4849fa36161e..2990447f45e9 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -217,8 +217,14 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
                 return PTR_ERR(bio);
 
         if (bio->bi_size != len) {
+                /*
+                 * Grab an extra reference to this bio, as bio_unmap_user()
+                 * expects to be able to drop it twice as it happens on the
+                 * normal IO completion path
+                 */
+                bio_get(bio);
                 bio_endio(bio, 0);
-                bio_unmap_user(bio);
+                __blk_rq_unmap_user(bio);
                 return -EINVAL;
         }
 
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 41392fbe19ff..afa55e14e278 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -125,6 +125,9 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
         q->nr_requests = BLKDEV_MAX_RQ;
         blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);
         blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);
+        blk_queue_segment_boundary(q, BLK_SEG_BOUNDARY_MASK);
+        blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);
+
         q->make_request_fn = mfn;
         q->backing_dev_info.ra_pages =
                         (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
@@ -314,6 +317,7 @@ void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
         /* zero is "infinity" */
         t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
         t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
+        t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, b->seg_boundary_mask);
 
         t->max_phys_segments = min(t->max_phys_segments, b->max_phys_segments);
         t->max_hw_segments = min(t->max_hw_segments, b->max_hw_segments);
diff --git a/block/elevator.c b/block/elevator.c
index 9ac82dde99dd..a6951f76ba0c 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -844,14 +844,7 @@ void elv_dequeue_request(struct request_queue *q, struct request *rq)
          */
         if (blk_account_rq(rq))
                 q->in_flight++;
-
-        /*
-         * We are now handing the request to the hardware, add the
-         * timeout handler.
-         */
-        blk_add_timer(rq);
 }
-EXPORT_SYMBOL(elv_dequeue_request);
 
 int elv_queue_empty(struct request_queue *q)
 {
diff --git a/block/genhd.c b/block/genhd.c
index 4e5e7493f676..2f7feda61e35 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -768,6 +768,8 @@ static int __init genhd_device_init(void)
         bdev_map = kobj_map_init(base_probe, &block_class_lock);
         blk_dev_init();
 
+        register_blkdev(BLOCK_EXT_MAJOR, "blkext");
+
 #ifndef CONFIG_SYSFS_DEPRECATED
         /* create top-level block dir */
         block_depr = kobject_create_and_add("block", NULL);
@@ -1100,6 +1102,7 @@ struct gendisk *alloc_disk_node(int minors, int node_id)
                         kfree(disk);
                         return NULL;
                 }
+                disk->node_id = node_id;
                 if (disk_expand_part_tbl(disk, 0)) {
                         free_part_stats(&disk->part0);
                         kfree(disk);
@@ -1114,7 +1117,6 @@ struct gendisk *alloc_disk_node(int minors, int node_id)
                 device_initialize(disk_to_dev(disk));
                 INIT_WORK(&disk->async_notify,
                         media_change_notify_thread);
-                disk->node_id = node_id;
         }
         return disk;
 }
diff --git a/block/ioctl.c b/block/ioctl.c
index c832d639b6e2..d03985b04d67 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -18,7 +18,6 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
         struct disk_part_iter piter;
         long long start, length;
         int partno;
-        int err;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
@@ -61,10 +60,10 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                         disk_part_iter_exit(&piter);
 
                         /* all seems OK */
-                        err = add_partition(disk, partno, start, length,
-                                            ADDPART_FLAG_NONE);
+                        part = add_partition(disk, partno, start, length,
+                                             ADDPART_FLAG_NONE);
                         mutex_unlock(&bdev->bd_mutex);
-                        return err;
+                        return IS_ERR(part) ? PTR_ERR(part) : 0;
                 case BLKPG_DEL_PARTITION:
                         part = disk_get_part(disk, partno);
                         if (!part)