Merge branch 'linus' into core/generic-dma-coherent

Conflicts:

	arch/x86/Kconfig

Signed-off-by: Ingo Molnar <mingo@elte.hu>

5 files changed, 127 insertions, 97 deletions

diff --git a/block/as-iosched.c b/block/as-iosched.c
index 9735acb5b4f5..cf4eb0eefbbf 100644
--- a/block/as-iosched.c
+++ b/block/as-iosched.c
@@ -837,8 +837,7 @@ static void as_completed_request(struct request_queue *q, struct request *rq)
         WARN_ON(!list_empty(&rq->queuelist));
 
         if (RQ_STATE(rq) != AS_RQ_REMOVED) {
-                printk("rq->state %d\n", RQ_STATE(rq));
-                WARN_ON(1);
+                WARN(1, "rq->state %d\n", RQ_STATE(rq));
                 goto out;
         }
 
diff --git a/block/blk-map.c b/block/blk-map.c
index ddd96fb11a7d..af37e4ae62f5 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -269,7 +269,6 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
         int reading = rq_data_dir(rq) == READ;
         int do_copy = 0;
         struct bio *bio;
-        unsigned long stack_mask = ~(THREAD_SIZE - 1);
 
         if (len > (q->max_hw_sectors << 9))
                 return -EINVAL;
@@ -278,11 +277,8 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
 
         kaddr = (unsigned long)kbuf;
         alignment = queue_dma_alignment(q) | q->dma_pad_mask;
-        do_copy = ((kaddr & alignment) || (len & alignment));
-
-        if (!((kaddr & stack_mask) ^
-              ((unsigned long)current->stack & stack_mask)))
-                do_copy = 1;
+        do_copy = ((kaddr & alignment) || (len & alignment) ||
+                   object_is_on_stack(kbuf));
 
         if (do_copy)
                 bio = bio_copy_kern(q, kbuf, len, gfp_mask, reading);
diff --git a/block/bsg.c b/block/bsg.c
index 5fb9b0bdbe85..5a68b09a69ba 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -1044,7 +1044,8 @@ int bsg_register_queue(struct request_queue *q, struct device *parent,
         bcd->release = release;
         kref_init(&bcd->ref);
         dev = MKDEV(bsg_major, bcd->minor);
-        class_dev = device_create(bsg_class, parent, dev, "%s", devname);
+        class_dev = device_create_drvdata(bsg_class, parent, dev, NULL,
+                                          "%s", devname);
         if (IS_ERR(class_dev)) {
                 ret = PTR_ERR(class_dev);
                 goto put_dev;
diff --git a/block/genhd.c b/block/genhd.c
index 9074f384b097..c13cc77291af 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -183,6 +183,7 @@ static int exact_lock(dev_t devt, void *data)
 void add_disk(struct gendisk *disk)
 {
         struct backing_dev_info *bdi;
+        int retval;
 
         disk->flags |= GENHD_FL_UP;
         blk_register_region(MKDEV(disk->major, disk->first_minor),
@@ -193,7 +194,8 @@ void add_disk(struct gendisk *disk)
 
         bdi = &disk->queue->backing_dev_info;
         bdi_register_dev(bdi, MKDEV(disk->major, disk->first_minor));
-        sysfs_create_link(&disk->dev.kobj, &bdi->dev->kobj, "bdi");
+        retval = sysfs_create_link(&disk->dev.kobj, &bdi->dev->kobj, "bdi");
+        WARN_ON(retval);
 }
 
 EXPORT_SYMBOL(add_disk);
@@ -225,89 +227,111 @@ struct gendisk *get_gendisk(dev_t devt, int *part)
 }
 
 /*
- * print a full list of all partitions - intended for places where the root
- * filesystem can't be mounted and thus to give the victim some idea of what
- * went wrong
+ * print a partitions - intended for places where the root filesystem can't be
+ * mounted and thus to give the victim some idea of what went wrong
  */
-void __init printk_all_partitions(void)
+static int printk_partition(struct device *dev, void *data)
 {
-        struct device *dev;
         struct gendisk *sgp;
         char buf[BDEVNAME_SIZE];
         int n;
 
-        mutex_lock(&block_class_lock);
-        /* For each block device... */
-        list_for_each_entry(dev, &block_class.devices, node) {
-                if (dev->type != &disk_type)
-                        continue;
-                sgp = dev_to_disk(dev);
-                /*
-                 * Don't show empty devices or things that have been surpressed
-                 */
-                if (get_capacity(sgp) == 0 ||
-                    (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
-                        continue;
+        if (dev->type != &disk_type)
+                goto exit;
 
-                /*
-                 * Note, unlike /proc/partitions, I am showing the numbers in
-                 * hex - the same format as the root= option takes.
-                 */
-                printk("%02x%02x %10llu %s",
-                        sgp->major, sgp->first_minor,
-                        (unsigned long long)get_capacity(sgp) >> 1,
-                        disk_name(sgp, 0, buf));
-                if (sgp->driverfs_dev != NULL &&
-                    sgp->driverfs_dev->driver != NULL)
-                        printk(" driver: %s\n",
-                                sgp->driverfs_dev->driver->name);
-                else
-                        printk(" (driver?)\n");
-
-                /* now show the partitions */
-                for (n = 0; n < sgp->minors - 1; ++n) {
-                        if (sgp->part[n] == NULL)
-                                continue;
-                        if (sgp->part[n]->nr_sects == 0)
-                                continue;
-                        printk("  %02x%02x %10llu %s\n",
-                                sgp->major, n + 1 + sgp->first_minor,
-                                (unsigned long long)sgp->part[n]->nr_sects >> 1,
-                                disk_name(sgp, n + 1, buf));
-                }
+        sgp = dev_to_disk(dev);
+        /*
+         * Don't show empty devices or things that have been surpressed
+         */
+        if (get_capacity(sgp) == 0 ||
+            (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
+                goto exit;
+
+        /*
+         * Note, unlike /proc/partitions, I am showing the numbers in
+         * hex - the same format as the root= option takes.
+         */
+        printk("%02x%02x %10llu %s",
+                sgp->major, sgp->first_minor,
+                (unsigned long long)get_capacity(sgp) >> 1,
+                disk_name(sgp, 0, buf));
+        if (sgp->driverfs_dev != NULL &&
+            sgp->driverfs_dev->driver != NULL)
+                printk(" driver: %s\n",
+                        sgp->driverfs_dev->driver->name);
+        else
+                printk(" (driver?)\n");
+
+        /* now show the partitions */
+        for (n = 0; n < sgp->minors - 1; ++n) {
+                if (sgp->part[n] == NULL)
+                        goto exit;
+                if (sgp->part[n]->nr_sects == 0)
+                        goto exit;
+                printk("  %02x%02x %10llu %s\n",
+                        sgp->major, n + 1 + sgp->first_minor,
+                        (unsigned long long)sgp->part[n]->nr_sects >> 1,
+                        disk_name(sgp, n + 1, buf));
         }
+exit:
+        return 0;
+}
 
+/*
+ * print a full list of all partitions - intended for places where the root
+ * filesystem can't be mounted and thus to give the victim some idea of what
+ * went wrong
+ */
+void __init printk_all_partitions(void)
+{
+        mutex_lock(&block_class_lock);
+        class_for_each_device(&block_class, NULL, NULL, printk_partition);
         mutex_unlock(&block_class_lock);
 }
 
 #ifdef CONFIG_PROC_FS
 /* iterator */
+static int find_start(struct device *dev, void *data)
+{
+        loff_t k = *(loff_t *)data;
+
+        if (dev->type != &disk_type)
+                return 0;
+        if (!k--)
+                return 1;
+        return 0;
+}
+
 static void *part_start(struct seq_file *part, loff_t *pos)
 {
-        loff_t k = *pos;
         struct device *dev;
+        loff_t n = *pos;
+
+        if (!n)
+                seq_puts(part, "major minor  #blocks  name\n\n");
 
         mutex_lock(&block_class_lock);
-        list_for_each_entry(dev, &block_class.devices, node) {
-                if (dev->type != &disk_type)
-                        continue;
-                if (!k--)
-                        return dev_to_disk(dev);
-        }
+        dev = class_find_device(&block_class, NULL, (void *)pos, find_start);
+        if (dev)
+                return dev_to_disk(dev);
         return NULL;
 }
 
+static int find_next(struct device *dev, void *data)
+{
+        if (dev->type == &disk_type)
+                return 1;
+        return 0;
+}
+
 static void *part_next(struct seq_file *part, void *v, loff_t *pos)
 {
         struct gendisk *gp = v;
         struct device *dev;
         ++*pos;
-        list_for_each_entry(dev, &gp->dev.node, node) {
-                if (&dev->node == &block_class.devices)
-                        return NULL;
-                if (dev->type == &disk_type)
-                        return dev_to_disk(dev);
-        }
+        dev = class_find_device(&block_class, &gp->dev, NULL, find_next);
+        if (dev)
+                return dev_to_disk(dev);
         return NULL;
 }
 
@@ -322,9 +346,6 @@ static int show_partition(struct seq_file *part, void *v)
         int n;
         char buf[BDEVNAME_SIZE];
 
-        if (&sgp->dev.node == block_class.devices.next)
-                seq_puts(part, "major minor  #blocks  name\n\n");
-
         /* Don't show non-partitionable removeable devices or empty devices */
         if (!get_capacity(sgp) ||
                         (sgp->minors == 1 && (sgp->flags & GENHD_FL_REMOVABLE)))
@@ -370,7 +391,10 @@ static struct kobject *base_probe(dev_t devt, int *part, void *data)
 
 static int __init genhd_device_init(void)
 {
-        int error = class_register(&block_class);
+        int error;
+
+        block_class.dev_kobj = sysfs_dev_block_kobj;
+        error = class_register(&block_class);
         if (unlikely(error))
                 return error;
         bdev_map = kobj_map_init(base_probe, &block_class_lock);
@@ -532,6 +556,7 @@ static struct device_type disk_type = {
         .release        = disk_release,
 };
 
+#ifdef CONFIG_PROC_FS
 /*
  * aggregate disk stat collector.  Uses the same stats that the sysfs
  * entries do, above, but makes them available through one seq_file.
@@ -542,16 +567,12 @@ static struct device_type disk_type = {
 
 static void *diskstats_start(struct seq_file *part, loff_t *pos)
 {
-        loff_t k = *pos;
         struct device *dev;
 
         mutex_lock(&block_class_lock);
-        list_for_each_entry(dev, &block_class.devices, node) {
-                if (dev->type != &disk_type)
-                        continue;
-                if (!k--)
-                        return dev_to_disk(dev);
-        }
+        dev = class_find_device(&block_class, NULL, (void *)pos, find_start);
+        if (dev)
+                return dev_to_disk(dev);
         return NULL;
 }
 
@@ -561,12 +582,9 @@ static void *diskstats_next(struct seq_file *part, void *v, loff_t *pos)
         struct device *dev;
 
         ++*pos;
-        list_for_each_entry(dev, &gp->dev.node, node) {
-                if (&dev->node == &block_class.devices)
-                        return NULL;
-                if (dev->type == &disk_type)
-                        return dev_to_disk(dev);
-        }
+        dev = class_find_device(&block_class, &gp->dev, NULL, find_next);
+        if (dev)
+                return dev_to_disk(dev);
         return NULL;
 }
 
@@ -641,6 +659,7 @@ const struct seq_operations diskstats_op = {
         .stop   = diskstats_stop,
         .show   = diskstats_show
 };
+#endif /* CONFIG_PROC_FS */
 
 static void media_change_notify_thread(struct work_struct *work)
 {
@@ -665,24 +684,38 @@ void genhd_media_change_notify(struct gendisk *disk)
 EXPORT_SYMBOL_GPL(genhd_media_change_notify);
 #endif  /*  0  */
 
+struct find_block {
+        const char *name;
+        int part;
+};
+
+static int match_id(struct device *dev, void *data)
+{
+        struct find_block *find = data;
+
+        if (dev->type != &disk_type)
+                return 0;
+        if (strcmp(dev->bus_id, find->name) == 0) {
+                struct gendisk *disk = dev_to_disk(dev);
+                if (find->part < disk->minors)
+                        return 1;
+        }
+        return 0;
+}
+
 dev_t blk_lookup_devt(const char *name, int part)
 {
         struct device *dev;
         dev_t devt = MKDEV(0, 0);
+        struct find_block find;
 
         mutex_lock(&block_class_lock);
-        list_for_each_entry(dev, &block_class.devices, node) {
-                if (dev->type != &disk_type)
-                        continue;
-                if (strcmp(dev->bus_id, name) == 0) {
-                        struct gendisk *disk = dev_to_disk(dev);
-
-                        if (part < disk->minors)
-                                devt = MKDEV(MAJOR(dev->devt),
-                                             MINOR(dev->devt) + part);
-                        break;
-                }
-        }
+        find.name = name;
+        find.part = part;
+        dev = class_find_device(&block_class, NULL, (void *)&find, match_id);
+        if (dev)
+                devt = MKDEV(MAJOR(dev->devt),
+                             MINOR(dev->devt) + part);
         mutex_unlock(&block_class_lock);
 
         return devt;
diff --git a/block/ioctl.c b/block/ioctl.c
index 52d6385216ad..77185e5c026a 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -17,6 +17,7 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
         long long start, length;
         int part;
         int i;
+        int err;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
@@ -61,9 +62,9 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                                 }
                         }
                         /* all seems OK */
-                        add_partition(disk, part, start, length, ADDPART_FLAG_NONE);
+                        err = add_partition(disk, part, start, length, ADDPART_FLAG_NONE);
                         mutex_unlock(&bdev->bd_mutex);
-                        return 0;
+                        return err;
                 case BLKPG_DEL_PARTITION:
                         if (!disk->part[part-1])
                                 return -ENXIO;