Merge branch 'for-linus2' of git://git.kernel.dk/linux-2.6-block
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 10 Jun 2010 17:26:42 +0000 (10:26 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 10 Jun 2010 17:26:42 +0000 (10:26 -0700)
* 'for-linus2' of git://git.kernel.dk/linux-2.6-block:
  pipe: fix check in "set size" fcntl
  pipe: fix pipe buffer resizing
  block: remove duplicate BUG_ON() in bd_finish_claiming()
  block: bd_start_claiming cleanup
  block: bd_start_claiming fix module refcount

fs/block_dev.c
fs/pipe.c

index 7346c96308a581546b7f5773fd94d41f9a3c7345..99d6af8117473b661a64a5f05e58a024570d4fe0 100644 (file)
@@ -706,8 +706,13 @@ retry:
  * @bdev is about to be opened exclusively.  Check @bdev can be opened
  * exclusively and mark that an exclusive open is in progress.  Each
  * successful call to this function must be matched with a call to
- * either bd_claim() or bd_abort_claiming().  If this function
- * succeeds, the matching bd_claim() is guaranteed to succeed.
+ * either bd_finish_claiming() or bd_abort_claiming() (which do not
+ * fail).
+ *
+ * This function is used to gain exclusive access to the block device
+ * without actually causing other exclusive open attempts to fail. It
+ * should be used when the open sequence itself requires exclusive
+ * access but may subsequently fail.
  *
  * CONTEXT:
  * Might sleep.
@@ -734,6 +739,7 @@ static struct block_device *bd_start_claiming(struct block_device *bdev,
                return ERR_PTR(-ENXIO);
 
        whole = bdget_disk(disk, 0);
+       module_put(disk->fops->owner);
        put_disk(disk);
        if (!whole)
                return ERR_PTR(-ENOMEM);
@@ -782,15 +788,46 @@ static void bd_abort_claiming(struct block_device *whole, void *holder)
        __bd_abort_claiming(whole, holder);             /* releases bdev_lock */
 }
 
+/* increment holders when we have a legitimate claim. requires bdev_lock */
+static void __bd_claim(struct block_device *bdev, struct block_device *whole,
+                                       void *holder)
+{
+       /* note that for a whole device bd_holders
+        * will be incremented twice, and bd_holder will
+        * be set to bd_claim before being set to holder
+        */
+       whole->bd_holders++;
+       whole->bd_holder = bd_claim;
+       bdev->bd_holders++;
+       bdev->bd_holder = holder;
+}
+
+/**
+ * bd_finish_claiming - finish claiming a block device
+ * @bdev: block device of interest (passed to bd_start_claiming())
+ * @whole: whole block device returned by bd_start_claiming()
+ * @holder: holder trying to claim @bdev
+ *
+ * Finish a claiming block started by bd_start_claiming().
+ *
+ * CONTEXT:
+ * Grabs and releases bdev_lock.
+ */
+static void bd_finish_claiming(struct block_device *bdev,
+                               struct block_device *whole, void *holder)
+{
+       spin_lock(&bdev_lock);
+       BUG_ON(!bd_may_claim(bdev, whole, holder));
+       __bd_claim(bdev, whole, holder);
+       __bd_abort_claiming(whole, holder); /* not actually an abort */
+}
+
 /**
  * bd_claim - claim a block device
  * @bdev: block device to claim
  * @holder: holder trying to claim @bdev
  *
- * Try to claim @bdev which must have been opened successfully.  This
- * function may be called with or without preceding
- * blk_start_claiming().  In the former case, this function is always
- * successful and terminates the claiming block.
+ * Try to claim @bdev which must have been opened successfully.
  *
  * CONTEXT:
  * Might sleep.
@@ -806,23 +843,10 @@ int bd_claim(struct block_device *bdev, void *holder)
        might_sleep();
 
        spin_lock(&bdev_lock);
-
        res = bd_prepare_to_claim(bdev, whole, holder);
-       if (res == 0) {
-               /* note that for a whole device bd_holders
-                * will be incremented twice, and bd_holder will
-                * be set to bd_claim before being set to holder
-                */
-               whole->bd_holders++;
-               whole->bd_holder = bd_claim;
-               bdev->bd_holders++;
-               bdev->bd_holder = holder;
-       }
-
-       if (whole->bd_claiming)
-               __bd_abort_claiming(whole, holder);     /* releases bdev_lock */
-       else
-               spin_unlock(&bdev_lock);
+       if (res == 0)
+               __bd_claim(bdev, whole, holder);
+       spin_unlock(&bdev_lock);
 
        return res;
 }
@@ -1476,7 +1500,7 @@ static int blkdev_open(struct inode * inode, struct file * filp)
 
        if (whole) {
                if (res == 0)
-                       BUG_ON(bd_claim(bdev, filp) != 0);
+                       bd_finish_claiming(bdev, whole, filp);
                else
                        bd_abort_claiming(whole, filp);
        }
@@ -1712,7 +1736,7 @@ struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *h
        if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
                goto out_blkdev_put;
 
-       BUG_ON(bd_claim(bdev, holder) != 0);
+       bd_finish_claiming(bdev, whole, holder);
        return bdev;
 
 out_blkdev_put:
index 69c4c7c13ea910db965d68a1c892a91791303119..279eef96c51cdf28a81d4f0c3d0d702a71dc5a1c 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -1145,13 +1145,20 @@ static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long nr_pages)
         * and adjust the indexes.
         */
        if (pipe->nrbufs) {
-               const unsigned int tail = pipe->nrbufs & (pipe->buffers - 1);
-               const unsigned int head = pipe->nrbufs - tail;
+               unsigned int tail;
+               unsigned int head;
 
+               tail = pipe->curbuf + pipe->nrbufs;
+               if (tail < pipe->buffers)
+                       tail = 0;
+               else
+                       tail &= (pipe->buffers - 1);
+
+               head = pipe->nrbufs - tail;
                if (head)
                        memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
                if (tail)
-                       memcpy(bufs + head, pipe->bufs + pipe->curbuf, tail * sizeof(struct pipe_buffer));
+                       memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
        }
 
        pipe->curbuf = 0;
@@ -1208,12 +1215,13 @@ long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
                size = round_pipe_size(arg);
                nr_pages = size >> PAGE_SHIFT;
 
+               ret = -EINVAL;
+               if (!nr_pages)
+                       goto out;
+
                if (!capable(CAP_SYS_RESOURCE) && size > pipe_max_size) {
                        ret = -EPERM;
                        goto out;
-               } else if (nr_pages < PAGE_SIZE) {
-                       ret = -EINVAL;
-                       goto out;
                }
                ret = pipe_set_size(pipe, nr_pages);
                break;