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

Pull block layer fixes from Jens Axboe: "Outside of bcache (which really isn't super big), these are all few-liners. There are a few important fixes in here: - Fix blk pm sleeping when holding the queue lock - A small collection of bcache fixes that have been done and tested since bcache was included in this merge window. - A fix for a raid5 regression introduced with the bio changes. - Two important fixes for mtip32xx, fixing an oops and potential data corruption (or hang) due to wrong bio iteration on stacked devices." * 'for-linus' of git://git.kernel.dk/linux-block: scatterlist: sg_set_buf() argument must be in linear mapping raid5: Initialize bi_vcnt pktcdvd: silence static checker warning block: remove refs to XD disks from documentation blkpm: avoid sleep when holding queue lock mtip32xx: Correctly handle bio->bi_idx != 0 conditions mtip32xx: Fix NULL pointer dereference during module unload bcache: Fix error handling in init code bcache: clarify free/available/unused space bcache: drop "select CLOSURES" bcache: Fix incompatible pointer type warning

Linus Torvalds committed 13 years ago

Commit b2cc9c12 parents a568fa1 ac4e97a14 files · +124 −143Browse files

Unified · Split

14 files

Documentation/bcache.txt +9 −3
Documentation/devices.txt +2 −6
Documentation/kernel-parameters.txt +0 −3
Documentation/m68k/kernel-options.txt +0 −2
block/blk-core.c +1 −1
drivers/block/mtip32xx/mtip32xx.c +5 −3
drivers/block/pktcdvd.c +2 −1
drivers/md/bcache/Kconfig +0 −1
drivers/md/bcache/bcache.h +1 −1
drivers/md/bcache/stats.c +16 −18
drivers/md/bcache/super.c +82 −103
drivers/md/bcache/writeback.c +1 −1
drivers/md/raid5.c +2 −0
include/linux/scatterlist.h +3 −0

Documentation/bcache.txt+9−3

   Symlink to each of the cache devices comprising this cache set.
 cache_available_percent
-  Percentage of cache device free.
+  Percentage of cache device which doesn't contain dirty data, and could
+  potentially be used for writeback.  This doesn't mean this space isn't used
+  for clean cached data; the unused statistic (in priority_stats) is typically
+  much lower.
 clear_stats
   Clears the statistics associated with this cache
   Total buckets in this cache
 priority_stats
-  Statistics about how recently data in the cache has been accessed.  This can
+  Statistics about how recently data in the cache has been accessed.
-  reveal your working set size.
+  This can reveal your working set size.  Unused is the percentage of
+  the cache that doesn't contain any data.  Metadata is bcache's
+  metadata overhead.  Average is the average priority of cache buckets.
+  Next is a list of quantiles with the priority threshold of each.
 written
   Sum of all data that has been written to the cache; comparison with

Documentation/devices.txt+2−6

 		Each device type has 5 bits (32 minors).
- 13 block	8-bit MFM/RLL/IDE controller
+ 13 block	Previously used for the XT disk (/dev/xdN)
-		  0 = /dev/xda		First XT disk whole disk
+		Deleted in kernel v3.9.
-		 64 = /dev/xdb		Second XT disk whole disk
-		Partitions are handled in the same way as IDE disks
-		(see major number 3).
  14 char	Open Sound System (OSS)
 		  0 = /dev/mixer	Mixer control

Documentation/kernel-parameters.txt+0−3

@@ -3351,9 +3351,6 @@ bytes respectively. Such letter suffixes can also be entirely omitted. · 3350 unmodified lines
3351	plus one apbt timer for broadcast timer.	3351	plus one apbt timer for broadcast timer.
3352	x86_mrst_timer=apbt_only \| lapic_and_apbt	3352	x86_mrst_timer=apbt_only \| lapic_and_apbt
3353		3353
3354	xd= [HW,XT] Original XT pre-IDE (RLL encoded) disks.
3355	xd_geo= See header of drivers/block/xd.c.
3356
3357	xen_emul_unplug= [HW,X86,XEN]	3354	xen_emul_unplug= [HW,X86,XEN]
3358	Unplug Xen emulated devices	3355	Unplug Xen emulated devices
3359	Format: [unplug0,][unplug1]	3356	Format: [unplug0,][unplug1]

Documentation/m68k/kernel-options.txt+0−2

@@ -80,8 +80,6 @@ Valid names are: · 79 unmodified lines
80	/dev/sdd: -> 0x0830 (forth SCSI disk)	80	/dev/sdd: -> 0x0830 (forth SCSI disk)
81	/dev/sde: -> 0x0840 (fifth SCSI disk)	81	/dev/sde: -> 0x0840 (fifth SCSI disk)
82	/dev/fd : -> 0x0200 (floppy disk)	82	/dev/fd : -> 0x0200 (floppy disk)
83	/dev/xda: -> 0x0c00 (first XT disk, unused in Linux/m68k)
84	/dev/xdb: -> 0x0c40 (second XT disk, unused in Linux/m68k)
85		83
86	The name must be followed by a decimal number, that stands for the	84	The name must be followed by a decimal number, that stands for the
87	partition number. Internally, the value of the number is just	85	partition number. Internally, the value of the number is just

block/blk-core.c+1−1

@@ -3164,7 +3164,7 @@ void blk_post_runtime_resume(struct request_queue *q, int err) · 3163 unmodified lines
3164	q->rpm_status = RPM_ACTIVE;	3164	q->rpm_status = RPM_ACTIVE;
3165	__blk_run_queue(q);	3165	__blk_run_queue(q);
3166	pm_runtime_mark_last_busy(q->dev);	3166	pm_runtime_mark_last_busy(q->dev);
3167	pm_runtime_autosuspend(q->dev);	3167	pm_request_autosuspend(q->dev);
3168	} else {	3168	} else {
3169	q->rpm_status = RPM_SUSPENDED;	3169	q->rpm_status = RPM_SUSPENDED;
3170	}	3170	}

drivers/block/mtip32xx/mtip32xx.c+5−3

 static void mtip_hw_debugfs_exit(struct driver_data *dd)
 {
-	debugfs_remove_recursive(dd->dfs_node);
+	if (dd->dfs_node)
+		debugfs_remove_recursive(dd->dfs_node);
 }
 	struct driver_data *dd = queue->queuedata;
 	struct scatterlist *sg;
 	struct bio_vec *bvec;
-	int nents = 0;
+	int i, nents = 0;
 	int tag = 0, unaligned = 0;
 	if (unlikely(dd->dd_flag & MTIP_DDF_STOP_IO)) {
 		}
 		/* Create the scatter list for this bio. */
-		bio_for_each_segment(bvec, bio, nents) {
+		bio_for_each_segment(bvec, bio, i) {
 			sg_set_page(&sg[nents],
 					bvec->bv_page,
 					bvec->bv_len,
 					bvec->bv_offset);
+			nents++;
 		}
 		/* Issue the read/write. */

drivers/block/pktcdvd.c+2−1

@@ -83,7 +83,8 @@ · 82 unmodified lines
83		83
84	#define MAX_SPEED 0xffff	84	#define MAX_SPEED 0xffff
85		85
86	#define ZONE(sector, pd) (((sector) + (pd)->offset) & ~((pd)->settings.size - 1))	86	#define ZONE(sector, pd) (((sector) + (pd)->offset) & \
		87	~(sector_t)((pd)->settings.size - 1))
87		88
88	static DEFINE_MUTEX(pktcdvd_mutex);	89	static DEFINE_MUTEX(pktcdvd_mutex);
89	static struct pktcdvd_device *pkt_devs[MAX_WRITERS];	90	static struct pktcdvd_device *pkt_devs[MAX_WRITERS];

drivers/md/bcache/Kconfig+0−1

@@ -1,7 +1,6 @@
1		1
2	config BCACHE	2	config BCACHE
3	tristate "Block device as cache"	3	tristate "Block device as cache"
4	select CLOSURES
5	---help---	4	---help---
6	Allows a block device to be used as cache for other devices; uses	5	Allows a block device to be used as cache for other devices; uses
7	a btree for indexing and the layout is optimized for SSDs.	6	a btree for indexing and the layout is optimized for SSDs.

drivers/md/bcache/bcache.h+1−1

@@ -1241,7 +1241,7 @@ void bch_cache_set_stop(struct cache_set *); · 1240 unmodified lines
1241	struct cache_set bch_cache_set_alloc(struct cache_sb );	1241	struct cache_set bch_cache_set_alloc(struct cache_sb );
1242	void bch_btree_cache_free(struct cache_set *);	1242	void bch_btree_cache_free(struct cache_set *);
1243	int bch_btree_cache_alloc(struct cache_set *);	1243	int bch_btree_cache_alloc(struct cache_set *);
1244	void bch_writeback_init_cached_dev(struct cached_dev *);	1244	void bch_cached_dev_writeback_init(struct cached_dev *);
1245	void bch_moving_init_cache_set(struct cache_set *);	1245	void bch_moving_init_cache_set(struct cache_set *);
1246		1246
1247	void bch_cache_allocator_exit(struct cache *ca);	1247	void bch_cache_allocator_exit(struct cache *ca);

drivers/md/bcache/stats.c+16−18

 };
 static KTYPE(bch_stats);
-static void scale_accounting(unsigned long data);
-void bch_cache_accounting_init(struct cache_accounting *acc,
-			       struct closure *parent)
-{
-	kobject_init(&acc->total.kobj,		&bch_stats_ktype);
-	kobject_init(&acc->five_minute.kobj,	&bch_stats_ktype);
-	kobject_init(&acc->hour.kobj,		&bch_stats_ktype);
-	kobject_init(&acc->day.kobj,		&bch_stats_ktype);
-	closure_init(&acc->cl, parent);
-	init_timer(&acc->timer);
-	acc->timer.expires	= jiffies + accounting_delay;
-	acc->timer.data		= (unsigned long) acc;
-	acc->timer.function	= scale_accounting;
-	add_timer(&acc->timer);
-}
 int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,
 				   struct kobject *parent)
 {
 	atomic_add(sectors, &dc->accounting.collector.sectors_bypassed);
 	atomic_add(sectors, &s->op.c->accounting.collector.sectors_bypassed);
 }
+void bch_cache_accounting_init(struct cache_accounting *acc,
+			       struct closure *parent)
+{
+	kobject_init(&acc->total.kobj,		&bch_stats_ktype);
+	kobject_init(&acc->five_minute.kobj,	&bch_stats_ktype);
+	kobject_init(&acc->hour.kobj,		&bch_stats_ktype);
+	kobject_init(&acc->day.kobj,		&bch_stats_ktype);
+	closure_init(&acc->cl, parent);
+	init_timer(&acc->timer);
+	acc->timer.expires	= jiffies + accounting_delay;
+	acc->timer.data		= (unsigned long) acc;
+	acc->timer.function	= scale_accounting;
+	add_timer(&acc->timer);
+}

drivers/md/bcache/super.c+82−103

@@ -634,11 +634,10 @@ static int open_dev(struct block_device *b, fmode_t mode) · 633 unmodified lines
634	return 0;	634	return 0;
635	}	635	}
636		636
637	static int release_dev(struct gendisk *b, fmode_t mode)	637	static void release_dev(struct gendisk *b, fmode_t mode)
638	{	638	{
639	struct bcache_device *d = b->private_data;	639	struct bcache_device *d = b->private_data;
640	closure_put(&d->cl);	640	closure_put(&d->cl);
641	return 0;
642	}	641	}
643		642
644	static int ioctl_dev(struct block_device *b, fmode_t mode,	643	static int ioctl_dev(struct block_device *b, fmode_t mode,
@@ -732,8 +731,7 @@ static void bcache_device_free(struct bcache_device *d) · 87 unmodified lines
732		731
733	if (d->c)	732	if (d->c)
734	bcache_device_detach(d);	733	bcache_device_detach(d);
735		734	if (d->disk && d->disk->flags & GENHD_FL_UP)
736	if (d->disk)
737	del_gendisk(d->disk);	735	del_gendisk(d->disk);
738	if (d->disk && d->disk->queue)	736	if (d->disk && d->disk->queue)
739	blk_cleanup_queue(d->disk->queue);	737	blk_cleanup_queue(d->disk->queue);
@@ -756,12 +754,9 @@ static int bcache_device_init(struct bcache_device *d, unsigned block_size) · 16 unmodified lines
756	if (!(d->bio_split = bioset_create(4, offsetof(struct bbio, bio))) \|\|	754	if (!(d->bio_split = bioset_create(4, offsetof(struct bbio, bio))) \|\|
757	!(d->unaligned_bvec = mempool_create_kmalloc_pool(1,	755	!(d->unaligned_bvec = mempool_create_kmalloc_pool(1,
758	sizeof(struct bio_vec) * BIO_MAX_PAGES)) \|\|	756	sizeof(struct bio_vec) * BIO_MAX_PAGES)) \|\|
759	bio_split_pool_init(&d->bio_split_hook))	757	bio_split_pool_init(&d->bio_split_hook) \|\|
760		758	!(d->disk = alloc_disk(1)) \|\|
761	return -ENOMEM;	759	!(q = blk_alloc_queue(GFP_KERNEL)))
762
763	d->disk = alloc_disk(1);
764	if (!d->disk)
765	return -ENOMEM;	760	return -ENOMEM;
766		761
767	snprintf(d->disk->disk_name, DISK_NAME_LEN, "bcache%i", bcache_minor);	762	snprintf(d->disk->disk_name, DISK_NAME_LEN, "bcache%i", bcache_minor);
@@ -771,10 +766,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned block_size) · 3 unmodified lines
771	d->disk->fops = &bcache_ops;	766	d->disk->fops = &bcache_ops;
772	d->disk->private_data = d;	767	d->disk->private_data = d;
773		768
774	q = blk_alloc_queue(GFP_KERNEL);
775	if (!q)
776	return -ENOMEM;
777
778	blk_queue_make_request(q, NULL);	769	blk_queue_make_request(q, NULL);
779	d->disk->queue = q;	770	d->disk->queue = q;
780	q->queuedata = d;	771	q->queuedata = d;
@@ -999,14 +990,17 @@ static void cached_dev_free(struct closure *cl) · 218 unmodified lines
999		990
1000	mutex_lock(&bch_register_lock);	991	mutex_lock(&bch_register_lock);
1001		992
1002	bd_unlink_disk_holder(dc->bdev, dc->disk.disk);	993	if (atomic_read(&dc->running))
		994	bd_unlink_disk_holder(dc->bdev, dc->disk.disk);
1003	bcache_device_free(&dc->disk);	995	bcache_device_free(&dc->disk);
1004	list_del(&dc->list);	996	list_del(&dc->list);
1005		997
1006	mutex_unlock(&bch_register_lock);	998	mutex_unlock(&bch_register_lock);
1007		999
1008	if (!IS_ERR_OR_NULL(dc->bdev)) {	1000	if (!IS_ERR_OR_NULL(dc->bdev)) {
1009	blk_sync_queue(bdev_get_queue(dc->bdev));	1001	if (dc->bdev->bd_disk)
		1002	blk_sync_queue(bdev_get_queue(dc->bdev));
		1003
1010	blkdev_put(dc->bdev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL);	1004	blkdev_put(dc->bdev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL);
1011	}	1005	}
1012		1006
@@ -1028,73 +1022,67 @@ static void cached_dev_flush(struct closure *cl) · 15 unmodified lines
1028		1022
1029	static int cached_dev_init(struct cached_dev *dc, unsigned block_size)	1023	static int cached_dev_init(struct cached_dev *dc, unsigned block_size)
1030	{	1024	{
1031	int err;	1025	int ret;
1032	struct io *io;	1026	struct io *io;
1033		1027	struct request_queue *q = bdev_get_queue(dc->bdev);
1034	closure_init(&dc->disk.cl, NULL);
1035	set_closure_fn(&dc->disk.cl, cached_dev_flush, system_wq);
1036		1028
1037	__module_get(THIS_MODULE);	1029	__module_get(THIS_MODULE);
1038	INIT_LIST_HEAD(&dc->list);	1030	INIT_LIST_HEAD(&dc->list);
		1031	closure_init(&dc->disk.cl, NULL);
		1032	set_closure_fn(&dc->disk.cl, cached_dev_flush, system_wq);
1039	kobject_init(&dc->disk.kobj, &bch_cached_dev_ktype);	1033	kobject_init(&dc->disk.kobj, &bch_cached_dev_ktype);
1040
1041	bch_cache_accounting_init(&dc->accounting, &dc->disk.cl);
1042
1043	err = bcache_device_init(&dc->disk, block_size);
1044	if (err)
1045	goto err;
1046
1047	spin_lock_init(&dc->io_lock);
1048	closure_init_unlocked(&dc->sb_write);
1049	INIT_WORK(&dc->detach, cached_dev_detach_finish);	1034	INIT_WORK(&dc->detach, cached_dev_detach_finish);
		1035	closure_init_unlocked(&dc->sb_write);
		1036	INIT_LIST_HEAD(&dc->io_lru);
		1037	spin_lock_init(&dc->io_lock);
		1038	bch_cache_accounting_init(&dc->accounting, &dc->disk.cl);
1050		1039
1051	dc->sequential_merge = true;	1040	dc->sequential_merge = true;
1052	dc->sequential_cutoff = 4 << 20;	1041	dc->sequential_cutoff = 4 << 20;
1053		1042
1054	INIT_LIST_HEAD(&dc->io_lru);
1055	dc->sb_bio.bi_max_vecs = 1;
1056	dc->sb_bio.bi_io_vec = dc->sb_bio.bi_inline_vecs;
1057
1058	for (io = dc->io; io < dc->io + RECENT_IO; io++) {	1043	for (io = dc->io; io < dc->io + RECENT_IO; io++) {
1059	list_add(&io->lru, &dc->io_lru);	1044	list_add(&io->lru, &dc->io_lru);
1060	hlist_add_head(&io->hash, dc->io_hash + RECENT_IO);	1045	hlist_add_head(&io->hash, dc->io_hash + RECENT_IO);
1061	}	1046	}
1062		1047
1063	bch_writeback_init_cached_dev(dc);	1048	ret = bcache_device_init(&dc->disk, block_size);
		1049	if (ret)
		1050	return ret;
		1051
		1052	set_capacity(dc->disk.disk,
		1053	dc->bdev->bd_part->nr_sects - dc->sb.data_offset);
		1054
		1055	dc->disk.disk->queue->backing_dev_info.ra_pages =
		1056	max(dc->disk.disk->queue->backing_dev_info.ra_pages,
		1057	q->backing_dev_info.ra_pages);
		1058
		1059	bch_cached_dev_request_init(dc);
		1060	bch_cached_dev_writeback_init(dc);
1064	return 0;	1061	return 0;
1065	err:
1066	bcache_device_stop(&dc->disk);
1067	return err;
1068	}	1062	}
1069		1063
1070	/* Cached device - bcache superblock */	1064	/* Cached device - bcache superblock */
1071		1065
1072	static const char register_bdev(struct cache_sb sb, struct page *sb_page,	1066	static void register_bdev(struct cache_sb sb, struct page sb_page,
1073	struct block_device *bdev,	1067	struct block_device *bdev,
1074	struct cached_dev *dc)	1068	struct cached_dev *dc)
1075	{	1069	{
1076	char name[BDEVNAME_SIZE];	1070	char name[BDEVNAME_SIZE];
1077	const char *err = "cannot allocate memory";	1071	const char *err = "cannot allocate memory";
1078	struct gendisk *g;
1079	struct cache_set *c;	1072	struct cache_set *c;
1080		1073
1081	if (!dc \|\| cached_dev_init(dc, sb->block_size << 9) != 0)
1082	return err;
1083
1084	memcpy(&dc->sb, sb, sizeof(struct cache_sb));	1074	memcpy(&dc->sb, sb, sizeof(struct cache_sb));
1085	dc->sb_bio.bi_io_vec[0].bv_page = sb_page;
1086	dc->bdev = bdev;	1075	dc->bdev = bdev;
1087	dc->bdev->bd_holder = dc;	1076	dc->bdev->bd_holder = dc;
1088		1077
1089	g = dc->disk.disk;	1078	bio_init(&dc->sb_bio);
1090		1079	dc->sb_bio.bi_max_vecs = 1;
1091	set_capacity(g, dc->bdev->bd_part->nr_sects - dc->sb.data_offset);	1080	dc->sb_bio.bi_io_vec = dc->sb_bio.bi_inline_vecs;
1092		1081	dc->sb_bio.bi_io_vec[0].bv_page = sb_page;
1093	g->queue->backing_dev_info.ra_pages =	1082	get_page(sb_page);
1094	max(g->queue->backing_dev_info.ra_pages,
1095	bdev->bd_queue->backing_dev_info.ra_pages);
1096		1083
1097	bch_cached_dev_request_init(dc);	1084	if (cached_dev_init(dc, sb->block_size << 9))
		1085	goto err;
1098		1086
1099	err = "error creating kobject";	1087	err = "error creating kobject";
1100	if (kobject_add(&dc->disk.kobj, &part_to_dev(bdev->bd_part)->kobj,	1088	if (kobject_add(&dc->disk.kobj, &part_to_dev(bdev->bd_part)->kobj,
@@ -1103,6 +1091,8 @@ static const char register_bdev(struct cache_sb sb, struct page *sb_page, · 2 unmodified lines
1103	if (bch_cache_accounting_add_kobjs(&dc->accounting, &dc->disk.kobj))	1091	if (bch_cache_accounting_add_kobjs(&dc->accounting, &dc->disk.kobj))
1104	goto err;	1092	goto err;
1105		1093
		1094	pr_info("registered backing device %s", bdevname(bdev, name));
		1095
1106	list_add(&dc->list, &uncached_devices);	1096	list_add(&dc->list, &uncached_devices);
1107	list_for_each_entry(c, &bch_cache_sets, list)	1097	list_for_each_entry(c, &bch_cache_sets, list)
1108	bch_cached_dev_attach(dc, c);	1098	bch_cached_dev_attach(dc, c);
@@ -1111,15 +1101,10 @@ static const char register_bdev(struct cache_sb sb, struct page *sb_page, · 2 unmodified lines
1111	BDEV_STATE(&dc->sb) == BDEV_STATE_STALE)	1101	BDEV_STATE(&dc->sb) == BDEV_STATE_STALE)
1112	bch_cached_dev_run(dc);	1102	bch_cached_dev_run(dc);
1113		1103
1114	return NULL;	1104	return;
1115	err:	1105	err:
1116	kobject_put(&dc->disk.kobj);
1117	pr_notice("error opening %s: %s", bdevname(bdev, name), err);	1106	pr_notice("error opening %s: %s", bdevname(bdev, name), err);
1118	/*	1107	bcache_device_stop(&dc->disk);
1119	* Return NULL instead of an error because kobject_put() cleans
1120	* everything up
1121	*/
1122	return NULL;
1123	}	1108	}
1124		1109
1125	/* Flash only volumes */	1110	/* Flash only volumes */
@@ -1717,20 +1702,11 @@ static int cache_alloc(struct cache_sb sb, struct cache ca) · 591 unmodified lines
1717	size_t free;	1702	size_t free;
1718	struct bucket *b;	1703	struct bucket *b;
1719		1704
1720	if (!ca)
1721	return -ENOMEM;
1722
1723	__module_get(THIS_MODULE);	1705	__module_get(THIS_MODULE);
1724	kobject_init(&ca->kobj, &bch_cache_ktype);	1706	kobject_init(&ca->kobj, &bch_cache_ktype);
1725		1707
1726	memcpy(&ca->sb, sb, sizeof(struct cache_sb));
1727
1728	INIT_LIST_HEAD(&ca->discards);	1708	INIT_LIST_HEAD(&ca->discards);
1729		1709
1730	bio_init(&ca->sb_bio);
1731	ca->sb_bio.bi_max_vecs = 1;
1732	ca->sb_bio.bi_io_vec = ca->sb_bio.bi_inline_vecs;
1733
1734	bio_init(&ca->journal.bio);	1710	bio_init(&ca->journal.bio);
1735	ca->journal.bio.bi_max_vecs = 8;	1711	ca->journal.bio.bi_max_vecs = 8;
1736	ca->journal.bio.bi_io_vec = ca->journal.bio.bi_inline_vecs;	1712	ca->journal.bio.bi_io_vec = ca->journal.bio.bi_inline_vecs;
@@ -1742,18 +1718,17 @@ static int cache_alloc(struct cache_sb sb, struct cache ca) · 5 unmodified lines
1742	!init_fifo(&ca->free_inc, free << 2, GFP_KERNEL) \|\|	1718	!init_fifo(&ca->free_inc, free << 2, GFP_KERNEL) \|\|
1743	!init_fifo(&ca->unused, free << 2, GFP_KERNEL) \|\|	1719	!init_fifo(&ca->unused, free << 2, GFP_KERNEL) \|\|
1744	!init_heap(&ca->heap, free << 3, GFP_KERNEL) \|\|	1720	!init_heap(&ca->heap, free << 3, GFP_KERNEL) \|\|
1745	!(ca->buckets = vmalloc(sizeof(struct bucket) *	1721	!(ca->buckets = vzalloc(sizeof(struct bucket) *
1746	ca->sb.nbuckets)) \|\|	1722	ca->sb.nbuckets)) \|\|
1747	!(ca->prio_buckets = kzalloc(sizeof(uint64_t) * prio_buckets(ca) *	1723	!(ca->prio_buckets = kzalloc(sizeof(uint64_t) * prio_buckets(ca) *
1748	2, GFP_KERNEL)) \|\|	1724	2, GFP_KERNEL)) \|\|
1749	!(ca->disk_buckets = alloc_bucket_pages(GFP_KERNEL, ca)) \|\|	1725	!(ca->disk_buckets = alloc_bucket_pages(GFP_KERNEL, ca)) \|\|
1750	!(ca->alloc_workqueue = alloc_workqueue("bch_allocator", 0, 1)) \|\|	1726	!(ca->alloc_workqueue = alloc_workqueue("bch_allocator", 0, 1)) \|\|
1751	bio_split_pool_init(&ca->bio_split_hook))	1727	bio_split_pool_init(&ca->bio_split_hook))
1752	goto err;	1728	return -ENOMEM;
1753		1729
1754	ca->prio_last_buckets = ca->prio_buckets + prio_buckets(ca);	1730	ca->prio_last_buckets = ca->prio_buckets + prio_buckets(ca);
1755		1731
1756	memset(ca->buckets, 0, ca->sb.nbuckets * sizeof(struct bucket));
1757	for_each_bucket(b, ca)	1732	for_each_bucket(b, ca)
1758	atomic_set(&b->pin, 0);	1733	atomic_set(&b->pin, 0);
1759		1734
@@ -1766,22 +1741,28 @@ err: · 6 unmodified lines
1766	return -ENOMEM;	1741	return -ENOMEM;
1767	}	1742	}
1768		1743
1769	static const char register_cache(struct cache_sb sb, struct page *sb_page,	1744	static void register_cache(struct cache_sb sb, struct page sb_page,
1770	struct block_device bdev, struct cache ca)	1745	struct block_device bdev, struct cache ca)
1771	{	1746	{
1772	char name[BDEVNAME_SIZE];	1747	char name[BDEVNAME_SIZE];
1773	const char *err = "cannot allocate memory";	1748	const char *err = "cannot allocate memory";
1774		1749
1775	if (cache_alloc(sb, ca) != 0)	1750	memcpy(&ca->sb, sb, sizeof(struct cache_sb));
1776	return err;
1777
1778	ca->sb_bio.bi_io_vec[0].bv_page = sb_page;
1779	ca->bdev = bdev;	1751	ca->bdev = bdev;
1780	ca->bdev->bd_holder = ca;	1752	ca->bdev->bd_holder = ca;
1781		1753
		1754	bio_init(&ca->sb_bio);
		1755	ca->sb_bio.bi_max_vecs = 1;
		1756	ca->sb_bio.bi_io_vec = ca->sb_bio.bi_inline_vecs;
		1757	ca->sb_bio.bi_io_vec[0].bv_page = sb_page;
		1758	get_page(sb_page);
		1759
1782	if (blk_queue_discard(bdev_get_queue(ca->bdev)))	1760	if (blk_queue_discard(bdev_get_queue(ca->bdev)))
1783	ca->discard = CACHE_DISCARD(&ca->sb);	1761	ca->discard = CACHE_DISCARD(&ca->sb);
1784		1762
		1763	if (cache_alloc(sb, ca) != 0)
		1764	goto err;
		1765
1785	err = "error creating kobject";	1766	err = "error creating kobject";
1786	if (kobject_add(&ca->kobj, &part_to_dev(bdev->bd_part)->kobj, "bcache"))	1767	if (kobject_add(&ca->kobj, &part_to_dev(bdev->bd_part)->kobj, "bcache"))
1787	goto err;	1768	goto err;
@@ -1791,15 +1772,10 @@ static const char register_cache(struct cache_sb sb, struct page *sb_page, · 3 unmodified lines
1791	goto err;	1772	goto err;
1792		1773
1793	pr_info("registered cache device %s", bdevname(bdev, name));	1774	pr_info("registered cache device %s", bdevname(bdev, name));
1794		1775	return;
1795	return NULL;
1796	err:	1776	err:
		1777	pr_notice("error opening %s: %s", bdevname(bdev, name), err);
1797	kobject_put(&ca->kobj);	1778	kobject_put(&ca->kobj);
1798	pr_info("error opening %s: %s", bdevname(bdev, name), err);
1799	/* Return NULL instead of an error because kobject_put() cleans
1800	* everything up
1801	*/
1802	return NULL;
1803	}	1779	}
1804		1780
1805	/* Global interfaces/init */	1781	/* Global interfaces/init */
@@ -1833,12 +1809,15 @@ static ssize_t register_bcache(struct kobject k, struct kobj_attribute attr, · 27 unmodified lines
1833	bdev = blkdev_get_by_path(strim(path),	1809	bdev = blkdev_get_by_path(strim(path),
1834	FMODE_READ\|FMODE_WRITE\|FMODE_EXCL,	1810	FMODE_READ\|FMODE_WRITE\|FMODE_EXCL,
1835	sb);	1811	sb);
1836	if (bdev == ERR_PTR(-EBUSY))	1812	if (IS_ERR(bdev)) {
1837	err = "device busy";	1813	if (bdev == ERR_PTR(-EBUSY))
1838		1814	err = "device busy";
1839	if (IS_ERR(bdev) \|\|
1840	set_blocksize(bdev, 4096))
1841	goto err;	1815	goto err;
		1816	}
		1817
		1818	err = "failed to set blocksize";
		1819	if (set_blocksize(bdev, 4096))
		1820	goto err_close;
1842		1821
1843	err = read_super(sb, bdev, &sb_page);	1822	err = read_super(sb, bdev, &sb_page);
1844	if (err)	1823	if (err)
@@ -1846,33 +1825,33 @@ static ssize_t register_bcache(struct kobject k, struct kobj_attribute attr, · 1 unmodified line
1846		1825
1847	if (SB_IS_BDEV(sb)) {	1826	if (SB_IS_BDEV(sb)) {
1848	struct cached_dev dc = kzalloc(sizeof(dc), GFP_KERNEL);	1827	struct cached_dev dc = kzalloc(sizeof(dc), GFP_KERNEL);
		1828	if (!dc)
		1829	goto err_close;
1849		1830
1850	err = register_bdev(sb, sb_page, bdev, dc);	1831	register_bdev(sb, sb_page, bdev, dc);
1851	} else {	1832	} else {
1852	struct cache ca = kzalloc(sizeof(ca), GFP_KERNEL);	1833	struct cache ca = kzalloc(sizeof(ca), GFP_KERNEL);
		1834	if (!ca)
		1835	goto err_close;
1853		1836
1854	err = register_cache(sb, sb_page, bdev, ca);	1837	register_cache(sb, sb_page, bdev, ca);
1855	}	1838	}
1856		1839	out:
1857	if (err) {	1840	if (sb_page)
1858	/* register_(bdev\|cache) will only return an error if they
1859	* didn't get far enough to create the kobject - if they did,
1860	* the kobject destructor will do this cleanup.
1861	*/
1862	put_page(sb_page);	1841	put_page(sb_page);
1863	err_close:
1864	blkdev_put(bdev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL);
1865	err:
1866	if (attr != &ksysfs_register_quiet)
1867	pr_info("error opening %s: %s", path, err);
1868	ret = -EINVAL;
1869	}
1870
1871	kfree(sb);	1842	kfree(sb);
1872	kfree(path);	1843	kfree(path);
1873	mutex_unlock(&bch_register_lock);	1844	mutex_unlock(&bch_register_lock);
1874	module_put(THIS_MODULE);	1845	module_put(THIS_MODULE);
1875	return ret;	1846	return ret;
		1847
		1848	err_close:
		1849	blkdev_put(bdev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL);
		1850	err:
		1851	if (attr != &ksysfs_register_quiet)
		1852	pr_info("error opening %s: %s", path, err);
		1853	ret = -EINVAL;
		1854	goto out;
1876	}	1855	}
1877		1856
1878	static int bcache_reboot(struct notifier_block n, unsigned long code, void x)	1857	static int bcache_reboot(struct notifier_block n, unsigned long code, void x)

drivers/md/bcache/writeback.c+1−1

@@ -375,7 +375,7 @@ err: · 374 unmodified lines
375	refill_dirty(cl);	375	refill_dirty(cl);
376	}	376	}
377		377
378	void bch_writeback_init_cached_dev(struct cached_dev *dc)	378	void bch_cached_dev_writeback_init(struct cached_dev *dc)
379	{	379	{
380	closure_init_unlocked(&dc->writeback);	380	closure_init_unlocked(&dc->writeback);
381	init_rwsem(&dc->writeback_lock);	381	init_rwsem(&dc->writeback_lock);

drivers/md/raid5.c+2−0

 			if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags))
 				bi->bi_rw |= REQ_FLUSH;
+			bi->bi_vcnt = 1;
 			bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
 			bi->bi_io_vec[0].bv_offset = 0;
 			bi->bi_size = STRIPE_SIZE;
 			else
 				rbi->bi_sector = (sh->sector
 						  + rrdev->data_offset);
+			rbi->bi_vcnt = 1;
 			rbi->bi_io_vec[0].bv_len = STRIPE_SIZE;
 			rbi->bi_io_vec[0].bv_offset = 0;
 			rbi->bi_size = STRIPE_SIZE;

include/linux/scatterlist.h+3−0

 static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
 			      unsigned int buflen)
 {
+#ifdef CONFIG_DEBUG_SG
+	BUG_ON(!virt_addr_valid(buf));
+#endif
 	sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
 }