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

Pull block fixes from Jens Axboe: "Here's the second round of block updates for this merge window. It's a mix of fixes for changes that went in previously in this round, and fixes in general. This pull request contains: - Fixes for loop from Christoph - A bdi vs gendisk lifetime fix from Dan, worth two cookies. - A blk-mq timeout fix, when on frozen queues. From Gabriel. - Writeback fix from Jan, ensuring that __writeback_single_inode() does the right thing. - Fix for bio->bi_rw usage in f2fs from me. - Error path deadlock fix in blk-mq sysfs registration from me. - Floppy O_ACCMODE fix from Jiri. - Fix to the new bio op methods from Mike. One more followup will be coming here, ensuring that we don't propagate the block types outside of block. That, and a rename of bio->bi_rw is coming right after -rc1 is cut. - Various little fixes" * 'for-linus' of git://git.kernel.dk/linux-block: mm/block: convert rw_page users to bio op use loop: make do_req_filebacked more robust loop: don't try to use AIO for discards blk-mq: fix deadlock in blk_mq_register_disk() error path Include: blkdev: Removed duplicate 'struct request;' declaration. Fixup direct bi_rw modifiers block: fix bdi vs gendisk lifetime mismatch blk-mq: Allow timeouts to run while queue is freezing nbd: fix race in ioctl block: fix use-after-free in seq file f2fs: drop bio->bi_rw manual assignment block: add missing group association in bio-cloning functions blkcg: kill unused field nr_undestroyed_grps writeback: Write dirty times for WB_SYNC_ALL writeback floppy: fix open(O_ACCMODE) for ioctl-only open

Linus Torvalds committed 10 years ago

Commit fff648d2 parents 62e6e9b abf545426 files · +168 −136Browse files

Unified · Split

26 files

block/bio.c +15 −0
block/blk-mq-sysfs.c +8 −4
block/blk-mq.c +14 −1
block/blk-throttle.c +0 −5
block/genhd.c +2 −1
drivers/block/brd.c +7 −10
drivers/block/floppy.c +9 −12
drivers/block/loop.c +30 −37
drivers/block/nbd.c +4 −8
drivers/block/zram/zram_drv.c +15 −13
drivers/nvdimm/btt.c +9 −9
drivers/nvdimm/pmem.c +6 −6
fs/block_dev.c +4 −3
fs/btrfs/extent_io.c +1 −7
fs/f2fs/data.c +0 −1
fs/fs-writeback.c +1 −0
fs/mpage.c +1 −1
include/linux/backing-dev-defs.h +1 −0
include/linux/backing-dev.h +1 −0
include/linux/bio.h +3 −0
include/linux/blk_types.h +11 −11
include/linux/blkdev.h +1 −2
include/linux/fs.h +2 −1
include/linux/pagemap.h +1 −1
mm/backing-dev.c +19 −0
mm/filemap.c +3 −3

block/bio.c+15−0

 	bio->bi_rw = bio_src->bi_rw;
 	bio->bi_iter = bio_src->bi_iter;
 	bio->bi_io_vec = bio_src->bi_io_vec;
+	bio_clone_blkcg_association(bio, bio_src);
 }
 EXPORT_SYMBOL(__bio_clone_fast);
 		}
 	}
+	bio_clone_blkcg_association(bio, bio_src);
 	return bio;
 }
 EXPORT_SYMBOL(bio_clone_bioset);
 	}
 }
+/**
+ * bio_clone_blkcg_association - clone blkcg association from src to dst bio
+ * @dst: destination bio
+ * @src: source bio
+ */
+void bio_clone_blkcg_association(struct bio *dst, struct bio *src)
+{
+	if (src->bi_css)
+		WARN_ON(bio_associate_blkcg(dst, src->bi_css));
+}
 #endif /* CONFIG_BLK_CGROUP */
 static void __init biovec_init_slabs(void)

block/blk-mq-sysfs.c+8−4

 	return ret;
 }
-void blk_mq_unregister_disk(struct gendisk *disk)
+static void __blk_mq_unregister_disk(struct gendisk *disk)
 {
 	struct request_queue *q = disk->queue;
 	struct blk_mq_hw_ctx *hctx;
 	struct blk_mq_ctx *ctx;
 	int i, j;
-	blk_mq_disable_hotplug();
 	queue_for_each_hw_ctx(q, hctx, i) {
 		blk_mq_unregister_hctx(hctx);
 	kobject_put(&disk_to_dev(disk)->kobj);
 	q->mq_sysfs_init_done = false;
+}
+void blk_mq_unregister_disk(struct gendisk *disk)
+{
+	blk_mq_disable_hotplug();
+	__blk_mq_unregister_disk(disk);
 	blk_mq_enable_hotplug();
 }
 	}
 	if (ret)
-		blk_mq_unregister_disk(disk);
+		__blk_mq_unregister_disk(disk);
 	else
 		q->mq_sysfs_init_done = true;
 out:

block/blk-mq.c+14−1

@@ -672,7 +672,20 @@ static void blk_mq_timeout_work(struct work_struct *work) · 671 unmodified lines
672	};	672	};
673	int i;	673	int i;
674		674
675	if (blk_queue_enter(q, true))	675	/* A deadlock might occur if a request is stuck requiring a
		676	* timeout at the same time a queue freeze is waiting
		677	* completion, since the timeout code would not be able to
		678	* acquire the queue reference here.
		679	*
		680	* That's why we don't use blk_queue_enter here; instead, we use
		681	* percpu_ref_tryget directly, because we need to be able to
		682	* obtain a reference even in the short window between the queue
		683	* starting to freeze, by dropping the first reference in
		684	* blk_mq_freeze_queue_start, and the moment the last request is
		685	* consumed, marked by the instant q_usage_counter reaches
		686	* zero.
		687	*/
		688	if (!percpu_ref_tryget(&q->q_usage_counter))
676	return;	689	return;
677		690
678	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &data);	691	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &data);

block/blk-throttle.c+0−5

 	/* Total Number of queued bios on READ and WRITE lists */
 	unsigned int nr_queued[2];
-	/*
-	 * number of total undestroyed groups
-	 */
-	unsigned int nr_undestroyed_grps;
 	/* Work for dispatching throttled bios */
 	struct work_struct dispatch_work;
 };

block/genhd.c+2−1

 	/* Register BDI before referencing it from bdev */
 	bdi = &disk->queue->backing_dev_info;
-	bdi_register_dev(bdi, disk_devt(disk));
+	bdi_register_owner(bdi, disk_to_dev(disk));
 	blk_register_region(disk_devt(disk), disk->minors, NULL,
 			    exact_match, exact_lock, disk);
 	if (iter) {
 		class_dev_iter_exit(iter);
 		kfree(iter);
+		seqf->private = NULL;
 	}
 }

drivers/block/brd.c+7−10

  * Process a single bvec of a bio.
  */
 static int brd_do_bvec(struct brd_device *brd, struct page *page,
-			unsigned int len, unsigned int off, int rw,
+			unsigned int len, unsigned int off, int op,
 			sector_t sector)
 {
 	void *mem;
 	int err = 0;
-	if (rw != READ) {
+	if (op_is_write(op)) {
 		err = copy_to_brd_setup(brd, sector, len);
 		if (err)
 			goto out;
 	}
 	mem = kmap_atomic(page);
-	if (rw == READ) {
+	if (!op_is_write(op)) {
 		copy_from_brd(mem + off, brd, sector, len);
 		flush_dcache_page(page);
 	} else {
 {
 	struct block_device *bdev = bio->bi_bdev;
 	struct brd_device *brd = bdev->bd_disk->private_data;
-	int rw;
 	struct bio_vec bvec;
 	sector_t sector;
 	struct bvec_iter iter;
 		goto out;
 	}
-	rw = bio_data_dir(bio);
 	bio_for_each_segment(bvec, bio, iter) {
 		unsigned int len = bvec.bv_len;
 		int err;
 		err = brd_do_bvec(brd, bvec.bv_page, len,
-					bvec.bv_offset, rw, sector);
+					bvec.bv_offset, bio_op(bio), sector);
 		if (err)
 			goto io_error;
 		sector += len >> SECTOR_SHIFT;
 }
 static int brd_rw_page(struct block_device *bdev, sector_t sector,
-		       struct page *page, int rw)
+		       struct page *page, int op)
 {
 	struct brd_device *brd = bdev->bd_disk->private_data;
-	int err = brd_do_bvec(brd, page, PAGE_SIZE, 0, rw, sector);
+	int err = brd_do_bvec(brd, page, PAGE_SIZE, 0, op, sector);
-	page_endio(page, rw & WRITE, err);
+	page_endio(page, op, err);
 	return err;
 }

drivers/block/floppy.c+9−12

 	opened_bdev[drive] = bdev;
-	if (!(mode & (FMODE_READ|FMODE_WRITE))) {
-		res = -EINVAL;
-		goto out;
-	}
 	res = -ENXIO;
 	if (!floppy_track_buffer) {
 	if (UFDCS->rawcmd == 1)
 		UFDCS->rawcmd = 2;
-	UDRS->last_checked = 0;
+	if (mode & (FMODE_READ|FMODE_WRITE)) {
-	clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
+		UDRS->last_checked = 0;
-	check_disk_change(bdev);
+		clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
-	if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
+		check_disk_change(bdev);
-		goto out;
+		if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
-	if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
+			goto out;
-		goto out;
+		if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
+			goto out;
+	}
 	res = -EROFS;

drivers/block/loop.c+30−37

@@ -510,14 +510,10 @@ static int lo_rw_aio(struct loop_device lo, struct loop_cmd cmd, · 509 unmodified lines
510	return 0;	510	return 0;
511	}	511	}
512		512
513		513	static int do_req_filebacked(struct loop_device lo, struct request rq)
514	static inline int lo_rw_simple(struct loop_device *lo,
515	struct request *rq, loff_t pos, bool rw)
516	{	514	{
517	struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);	515	struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
518		516	loff_t pos = ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset;
519	if (cmd->use_aio)
520	return lo_rw_aio(lo, cmd, pos, rw);
521		517
522	/*	518	/*
523	* lo_write_simple and lo_read_simple should have been covered	519	* lo_write_simple and lo_read_simple should have been covered
@@ -528,37 +524,30 @@ static inline int lo_rw_simple(struct loop_device *lo, · 4 unmodified lines
528	* of the req at one time. And direct read IO doesn't need to	524	* of the req at one time. And direct read IO doesn't need to
529	* run flush_dcache_page().	525	* run flush_dcache_page().
530	*/	526	*/
531	if (rw == WRITE)	527	switch (req_op(rq)) {
532	return lo_write_simple(lo, rq, pos);	528	case REQ_OP_FLUSH:
533	else	529	return lo_req_flush(lo, rq);
534	return lo_read_simple(lo, rq, pos);	530	case REQ_OP_DISCARD:
535	}	531	return lo_discard(lo, rq, pos);
536		532	case REQ_OP_WRITE:
537	static int do_req_filebacked(struct loop_device lo, struct request rq)	533	if (lo->transfer)
538	{	534	return lo_write_transfer(lo, rq, pos);
539	loff_t pos;	535	else if (cmd->use_aio)
540	int ret;	536	return lo_rw_aio(lo, cmd, pos, WRITE);
541
542	pos = ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset;
543
544	if (op_is_write(req_op(rq))) {
545	if (req_op(rq) == REQ_OP_FLUSH)
546	ret = lo_req_flush(lo, rq);
547	else if (req_op(rq) == REQ_OP_DISCARD)
548	ret = lo_discard(lo, rq, pos);
549	else if (lo->transfer)
550	ret = lo_write_transfer(lo, rq, pos);
551	else	537	else
552	ret = lo_rw_simple(lo, rq, pos, WRITE);	538	return lo_write_simple(lo, rq, pos);
553		539	case REQ_OP_READ:
554	} else {
555	if (lo->transfer)	540	if (lo->transfer)
556	ret = lo_read_transfer(lo, rq, pos);	541	return lo_read_transfer(lo, rq, pos);
		542	else if (cmd->use_aio)
		543	return lo_rw_aio(lo, cmd, pos, READ);
557	else	544	else
558	ret = lo_rw_simple(lo, rq, pos, READ);	545	return lo_read_simple(lo, rq, pos);
		546	default:
		547	WARN_ON_ONCE(1);
		548	return -EIO;
		549	break;
559	}	550	}
560
561	return ret;
562	}	551	}
563		552
564	struct switch_request {	553	struct switch_request {
@@ -1659,11 +1648,15 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx, · 1094 unmodified lines
1659	if (lo->lo_state != Lo_bound)	1648	if (lo->lo_state != Lo_bound)
1660	return -EIO;	1649	return -EIO;
1661		1650
1662	if (lo->use_dio && (req_op(cmd->rq) != REQ_OP_FLUSH \|\|	1651	switch (req_op(cmd->rq)) {
1663	req_op(cmd->rq) == REQ_OP_DISCARD))	1652	case REQ_OP_FLUSH:
1664	cmd->use_aio = true;	1653	case REQ_OP_DISCARD:
1665	else
1666	cmd->use_aio = false;	1654	cmd->use_aio = false;
		1655	break;
		1656	default:
		1657	cmd->use_aio = lo->use_dio;
		1658	break;
		1659	}
1667		1660
1668	queue_kthread_work(&lo->worker, &cmd->work);	1661	queue_kthread_work(&lo->worker, &cmd->work);
1669		1662

drivers/block/nbd.c+4−8

 	sk_set_memalloc(nbd->sock->sk);
-	nbd->task_recv = current;
 	ret = device_create_file(disk_to_dev(nbd->disk), &pid_attr);
 	if (ret) {
 		dev_err(disk_to_dev(nbd->disk), "device_create_file failed!\n");
-		nbd->task_recv = NULL;
 		return ret;
 	}
 	nbd_size_clear(nbd, bdev);
 	device_remove_file(disk_to_dev(nbd->disk), &pid_attr);
-	nbd->task_recv = NULL;
 	return ret;
 }
 		if (!nbd->sock)
 			return -EINVAL;
+		/* We have to claim the device under the lock */
+		nbd->task_recv = current;
 		mutex_unlock(&nbd->tx_lock);
 		nbd_parse_flags(nbd, bdev);
 				     nbd_name(nbd));
 		if (IS_ERR(thread)) {
 			mutex_lock(&nbd->tx_lock);
+			nbd->task_recv = NULL;
 			return PTR_ERR(thread);
 		}
 		kthread_stop(thread);
 		mutex_lock(&nbd->tx_lock);
+		nbd->task_recv = NULL;
 		sock_shutdown(nbd);
 		nbd_clear_que(nbd);

drivers/block/zram/zram_drv.c+15−13

 }
 static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
-			int offset, int rw)
+			int offset, int op)
 {
 	unsigned long start_time = jiffies;
 	int ret;
-	generic_start_io_acct(rw, bvec->bv_len >> SECTOR_SHIFT,
+	generic_start_io_acct(op, bvec->bv_len >> SECTOR_SHIFT,
 			&zram->disk->part0);
-	if (rw == READ) {
+	if (!op_is_write(op)) {
 		atomic64_inc(&zram->stats.num_reads);
 		ret = zram_bvec_read(zram, bvec, index, offset);
 	} else {
 		ret = zram_bvec_write(zram, bvec, index, offset);
 	}
-	generic_end_io_acct(rw, &zram->disk->part0, start_time);
+	generic_end_io_acct(op, &zram->disk->part0, start_time);
 	if (unlikely(ret)) {
-		if (rw == READ)
+		if (!op_is_write(op))
 			atomic64_inc(&zram->stats.failed_reads);
 		else
 			atomic64_inc(&zram->stats.failed_writes);
 static void __zram_make_request(struct zram *zram, struct bio *bio)
 {
-	int offset, rw;
+	int offset;
 	u32 index;
 	struct bio_vec bvec;
 	struct bvec_iter iter;
 		return;
 	}
-	rw = bio_data_dir(bio);
 	bio_for_each_segment(bvec, bio, iter) {
 		int max_transfer_size = PAGE_SIZE - offset;
 			bv.bv_len = max_transfer_size;
 			bv.bv_offset = bvec.bv_offset;
-			if (zram_bvec_rw(zram, &bv, index, offset, rw) < 0)
+			if (zram_bvec_rw(zram, &bv, index, offset,
+					 bio_op(bio)) < 0)
 				goto out;
 			bv.bv_len = bvec.bv_len - max_transfer_size;
 			bv.bv_offset += max_transfer_size;
-			if (zram_bvec_rw(zram, &bv, index + 1, 0, rw) < 0)
+			if (zram_bvec_rw(zram, &bv, index + 1, 0,
+					 bio_op(bio)) < 0)
 				goto out;
 		} else
-			if (zram_bvec_rw(zram, &bvec, index, offset, rw) < 0)
+			if (zram_bvec_rw(zram, &bvec, index, offset,
+					 bio_op(bio)) < 0)
 				goto out;
 		update_position(&index, &offset, &bvec);
 }
 static int zram_rw_page(struct block_device *bdev, sector_t sector,
-		       struct page *page, int rw)
+		       struct page *page, int op)
 {
 	int offset, err = -EIO;
 	u32 index;
 	bv.bv_len = PAGE_SIZE;
 	bv.bv_offset = 0;
-	err = zram_bvec_rw(zram, &bv, index, offset, rw);
+	err = zram_bvec_rw(zram, &bv, index, offset, op);
 put_zram:
 	zram_meta_put(zram);
 out:
 	 * (e.g., SetPageError, set_page_dirty and extra works).
 	 */
 	if (err == 0)
-		page_endio(page, rw, 0);
+		page_endio(page, op, 0);
 	return err;
 }

drivers/nvdimm/btt.c+9−9

 static int btt_do_bvec(struct btt *btt, struct bio_integrity_payload *bip,
 			struct page *page, unsigned int len, unsigned int off,
-			int rw, sector_t sector)
+			int op, sector_t sector)
 {
 	int ret;
-	if (rw == READ) {
+	if (!op_is_write(op)) {
 		ret = btt_read_pg(btt, bip, page, off, sector, len);
 		flush_dcache_page(page);
 	} else {
 	struct bvec_iter iter;
 	unsigned long start;
 	struct bio_vec bvec;
-	int err = 0, rw;
+	int err = 0;
 	bool do_acct;
 	/*
 	}
 	do_acct = nd_iostat_start(bio, &start);
-	rw = bio_data_dir(bio);
 	bio_for_each_segment(bvec, bio, iter) {
 		unsigned int len = bvec.bv_len;
 		BUG_ON(len % btt->sector_size);
 		err = btt_do_bvec(btt, bip, bvec.bv_page, len, bvec.bv_offset,
-				rw, iter.bi_sector);
+				  bio_op(bio), iter.bi_sector);
 		if (err) {
 			dev_info(&btt->nd_btt->dev,
 					"io error in %s sector %lld, len %d,\n",
-					(rw == READ) ? "READ" : "WRITE",
+					(op_is_write(bio_op(bio))) ? "WRITE" :
+					"READ",
 					(unsigned long long) iter.bi_sector, len);
 			bio->bi_error = err;
 			break;
 }
 static int btt_rw_page(struct block_device *bdev, sector_t sector,
-		struct page *page, int rw)
+		struct page *page, int op)
 {
 	struct btt *btt = bdev->bd_disk->private_data;
-	btt_do_bvec(btt, NULL, page, PAGE_SIZE, 0, rw, sector);
+	btt_do_bvec(btt, NULL, page, PAGE_SIZE, 0, op, sector);
-	page_endio(page, rw & WRITE, 0);
+	page_endio(page, op, 0);
 	return 0;
 }

drivers/nvdimm/pmem.c+6−6

@@ -67,7 +67,7 @@ static void pmem_clear_poison(struct pmem_device *pmem, phys_addr_t offset, · 66 unmodified lines
67	}	67	}
68		68
69	static int pmem_do_bvec(struct pmem_device pmem, struct page page,	69	static int pmem_do_bvec(struct pmem_device pmem, struct page page,
70	unsigned int len, unsigned int off, int rw,	70	unsigned int len, unsigned int off, int op,
71	sector_t sector)	71	sector_t sector)
72	{	72	{
73	int rc = 0;	73	int rc = 0;
@@ -79,7 +79,7 @@ static int pmem_do_bvec(struct pmem_device pmem, struct page page, · 5 unmodified lines
79	if (unlikely(is_bad_pmem(&pmem->bb, sector, len)))	79	if (unlikely(is_bad_pmem(&pmem->bb, sector, len)))
80	bad_pmem = true;	80	bad_pmem = true;
81		81
82	if (rw == READ) {	82	if (!op_is_write(op)) {
83	if (unlikely(bad_pmem))	83	if (unlikely(bad_pmem))
84	rc = -EIO;	84	rc = -EIO;
85	else {	85	else {
@@ -134,7 +134,7 @@ static blk_qc_t pmem_make_request(struct request_queue q, struct bio bio) · 48 unmodified lines
134	do_acct = nd_iostat_start(bio, &start);	134	do_acct = nd_iostat_start(bio, &start);
135	bio_for_each_segment(bvec, bio, iter) {	135	bio_for_each_segment(bvec, bio, iter) {
136	rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len,	136	rc = pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len,
137	bvec.bv_offset, bio_data_dir(bio),	137	bvec.bv_offset, bio_op(bio),
138	iter.bi_sector);	138	iter.bi_sector);
139	if (rc) {	139	if (rc) {
140	bio->bi_error = rc;	140	bio->bi_error = rc;
@@ -152,12 +152,12 @@ static blk_qc_t pmem_make_request(struct request_queue q, struct bio bio) · 11 unmodified lines
152	}	152	}
153		153
154	static int pmem_rw_page(struct block_device *bdev, sector_t sector,	154	static int pmem_rw_page(struct block_device *bdev, sector_t sector,
155	struct page *page, int rw)	155	struct page *page, int op)
156	{	156	{
157	struct pmem_device *pmem = bdev->bd_queue->queuedata;	157	struct pmem_device *pmem = bdev->bd_queue->queuedata;
158	int rc;	158	int rc;
159		159
160	rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, rw, sector);	160	rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, op, sector);
161		161
162	/*	162	/*
163	* The ->rw_page interface is subtle and tricky. The core	163	* The ->rw_page interface is subtle and tricky. The core
@@ -166,7 +166,7 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector, · 2 unmodified lines
166	* caused by double completion.	166	* caused by double completion.
167	*/	167	*/
168	if (rc == 0)	168	if (rc == 0)
169	page_endio(page, rw & WRITE, 0);	169	page_endio(page, op, 0);
170		170
171	return rc;	171	return rc;
172	}	172	}

fs/block_dev.c+4−3

 	result = blk_queue_enter(bdev->bd_queue, false);
 	if (result)
 		return result;
-	result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, READ);
+	result = ops->rw_page(bdev, sector + get_start_sect(bdev), page,
+			      REQ_OP_READ);
 	blk_queue_exit(bdev->bd_queue);
 	return result;
 }
 			struct page *page, struct writeback_control *wbc)
 {
 	int result;
-	int rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE;
 	const struct block_device_operations *ops = bdev->bd_disk->fops;
 	if (!ops->rw_page || bdev_get_integrity(bdev))
 		return result;
 	set_page_writeback(page);
-	result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, rw);
+	result = ops->rw_page(bdev, sector + get_start_sect(bdev), page,
+			      REQ_OP_WRITE);
 	if (result)
 		end_page_writeback(page);
 	else

fs/btrfs/extent_io.c+1−7

 		return -EIO;
 	}
 	bio->bi_bdev = dev->bdev;
-	bio->bi_rw = WRITE_SYNC;
+	bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_SYNC);
 	bio_add_page(bio, page, length, pg_offset);
 	if (btrfsic_submit_bio_wait(bio)) {
 		btrfs_bio->csum = NULL;
 		btrfs_bio->csum_allocated = NULL;
 		btrfs_bio->end_io = NULL;
-#ifdef CONFIG_BLK_CGROUP
-		/* FIXME, put this into bio_clone_bioset */
-		if (bio->bi_css)
-			bio_associate_blkcg(new, bio->bi_css);
-#endif
 	}
 	return new;
 }

fs/f2fs/data.c+0−1

@@ -245,7 +245,6 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) · 244 unmodified lines
245	bio_put(bio);	245	bio_put(bio);
246	return -EFAULT;	246	return -EFAULT;
247	}	247	}
248	bio->bi_rw = fio->op_flags;
249	bio_set_op_attrs(bio, fio->op, fio->op_flags);	248	bio_set_op_attrs(bio, fio->op, fio->op_flags);
250		249
251	__submit_bio(fio->sbi, bio, fio->type);	250	__submit_bio(fio->sbi, bio, fio->type);

fs/fs-writeback.c+1−0

@@ -1327,6 +1327,7 @@ __writeback_single_inode(struct inode inode, struct writeback_control wbc) · 1326 unmodified lines
1327	dirty = inode->i_state & I_DIRTY;	1327	dirty = inode->i_state & I_DIRTY;
1328	if (inode->i_state & I_DIRTY_TIME) {	1328	if (inode->i_state & I_DIRTY_TIME) {
1329	if ((dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) \|\|	1329	if ((dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) \|\|
		1330	wbc->sync_mode == WB_SYNC_ALL \|\|
1330	unlikely(inode->i_state & I_DIRTY_TIME_EXPIRED) \|\|	1331	unlikely(inode->i_state & I_DIRTY_TIME_EXPIRED) \|\|
1331	unlikely(time_after(jiffies,	1332	unlikely(time_after(jiffies,
1332	(inode->dirtied_time_when +	1333	(inode->dirtied_time_when +

fs/mpage.c+1−1

@@ -50,7 +50,7 @@ static void mpage_end_io(struct bio *bio) · 49 unmodified lines
50		50
51	bio_for_each_segment_all(bv, bio, i) {	51	bio_for_each_segment_all(bv, bio, i) {
52	struct page *page = bv->bv_page;	52	struct page *page = bv->bv_page;
53	page_endio(page, bio_data_dir(bio), bio->bi_error);	53	page_endio(page, bio_op(bio), bio->bi_error);
54	}	54	}
55		55
56	bio_put(bio);	56	bio_put(bio);

include/linux/backing-dev-defs.h+1−0

@@ -163,6 +163,7 @@ struct backing_dev_info { · 162 unmodified lines
163	wait_queue_head_t wb_waitq;	163	wait_queue_head_t wb_waitq;
164		164
165	struct device *dev;	165	struct device *dev;
		166	struct device *owner;
166		167
167	struct timer_list laptop_mode_wb_timer;	168	struct timer_list laptop_mode_wb_timer;
168		169

include/linux/backing-dev.h+1−0

@@ -24,6 +24,7 @@ __printf(3, 4) · 23 unmodified lines
24	int bdi_register(struct backing_dev_info bdi, struct device parent,	24	int bdi_register(struct backing_dev_info bdi, struct device parent,
25	const char *fmt, ...);	25	const char *fmt, ...);
26	int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);	26	int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
		27	int bdi_register_owner(struct backing_dev_info bdi, struct device owner);
27	void bdi_unregister(struct backing_dev_info *bdi);	28	void bdi_unregister(struct backing_dev_info *bdi);
28		29
29	int __must_check bdi_setup_and_register(struct backing_dev_info , char );	30	int __must_check bdi_setup_and_register(struct backing_dev_info , char );

include/linux/bio.h+3−0

 int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
 int bio_associate_current(struct bio *bio);
 void bio_disassociate_task(struct bio *bio);
+void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
 #else	/* CONFIG_BLK_CGROUP */
 static inline int bio_associate_blkcg(struct bio *bio,
 			struct cgroup_subsys_state *blkcg_css) { return 0; }
 static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
 static inline void bio_disassociate_task(struct bio *bio) { }
+static inline void bio_clone_blkcg_association(struct bio *dst,
+			struct bio *src) { }
 #endif	/* CONFIG_BLK_CGROUP */
 #ifdef CONFIG_HIGHMEM

include/linux/blk_types.h+11−11

 typedef void (bio_end_io_t) (struct bio *);
 typedef void (bio_destructor_t) (struct bio *);
+enum req_op {
+	REQ_OP_READ,
+	REQ_OP_WRITE,
+	REQ_OP_DISCARD,		/* request to discard sectors */
+	REQ_OP_SECURE_ERASE,	/* request to securely erase sectors */
+	REQ_OP_WRITE_SAME,	/* write same block many times */
+	REQ_OP_FLUSH,		/* request for cache flush */
+};
+#define REQ_OP_BITS 3
 #ifdef CONFIG_BLOCK
 /*
  * main unit of I/O for the block layer and lower layers (ie drivers and
 #define REQ_HASHED		(1ULL << __REQ_HASHED)
 #define REQ_MQ_INFLIGHT		(1ULL << __REQ_MQ_INFLIGHT)
-enum req_op {
-	REQ_OP_READ,
-	REQ_OP_WRITE,
-	REQ_OP_DISCARD,		/* request to discard sectors */
-	REQ_OP_SECURE_ERASE,	/* request to securely erase sectors */
-	REQ_OP_WRITE_SAME,	/* write same block many times */
-	REQ_OP_FLUSH,		/* request for cache flush */
-};
-#define REQ_OP_BITS 3
 typedef unsigned int blk_qc_t;
 #define BLK_QC_T_NONE	-1U
 #define BLK_QC_T_SHIFT	16

include/linux/blkdev.h+1−2

  */
 #define BLKCG_MAX_POLS		2
-struct request;
 typedef void (rq_end_io_fn)(struct request *, int);
 #define BLK_RL_SYNCFULL		(1U << 0)
 struct block_device_operations {
 	int (*open) (struct block_device *, fmode_t);
 	void (*release) (struct gendisk *, fmode_t);
-	int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
+	int (*rw_page)(struct block_device *, sector_t, struct page *, int op);
 	int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
 	int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
 	long (*direct_access)(struct block_device *, sector_t, void **, pfn_t *,

include/linux/fs.h+2−1

 extern void make_bad_inode(struct inode *);
 extern bool is_bad_inode(struct inode *);
-#ifdef CONFIG_BLOCK
 static inline bool op_is_write(unsigned int op)
 {
 	return op == REQ_OP_READ ? false : true;
 }
+#ifdef CONFIG_BLOCK
 /*
  * return data direction, READ or WRITE
  */

include/linux/pagemap.h+1−1

@@ -510,7 +510,7 @@ static inline void wait_on_page_writeback(struct page *page) · 509 unmodified lines
510	extern void end_page_writeback(struct page *page);	510	extern void end_page_writeback(struct page *page);
511	void wait_for_stable_page(struct page *page);	511	void wait_for_stable_page(struct page *page);
512		512
513	void page_endio(struct page *page, int rw, int err);	513	void page_endio(struct page *page, int op, int err);
514		514
515	/*	515	/*
516	* Add an arbitrary waiter to a page's wait queue	516	* Add an arbitrary waiter to a page's wait queue

mm/backing-dev.c+19−0

@@ -825,6 +825,20 @@ int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev) · 824 unmodified lines
825	}	825	}
826	EXPORT_SYMBOL(bdi_register_dev);	826	EXPORT_SYMBOL(bdi_register_dev);
827		827
		828	int bdi_register_owner(struct backing_dev_info bdi, struct device owner)
		829	{
		830	int rc;
		831
		832	rc = bdi_register(bdi, NULL, "%u:%u", MAJOR(owner->devt),
		833	MINOR(owner->devt));
		834	if (rc)
		835	return rc;
		836	bdi->owner = owner;
		837	get_device(owner);
		838	return 0;
		839	}
		840	EXPORT_SYMBOL(bdi_register_owner);
		841
828	/*	842	/*
829	* Remove bdi from bdi_list, and ensure that it is no longer visible	843	* Remove bdi from bdi_list, and ensure that it is no longer visible
830	*/	844	*/
@@ -849,6 +863,11 @@ void bdi_unregister(struct backing_dev_info *bdi) · 18 unmodified lines
849	device_unregister(bdi->dev);	863	device_unregister(bdi->dev);
850	bdi->dev = NULL;	864	bdi->dev = NULL;
851	}	865	}
		866
		867	if (bdi->owner) {
		868	put_device(bdi->owner);
		869	bdi->owner = NULL;
		870	}
852	}	871	}
853		872
854	void bdi_exit(struct backing_dev_info *bdi)	873	void bdi_exit(struct backing_dev_info *bdi)

mm/filemap.c+3−3

@@ -887,9 +887,9 @@ EXPORT_SYMBOL(end_page_writeback); · 886 unmodified lines
887	* After completing I/O on a page, call this routine to update the page	887	* After completing I/O on a page, call this routine to update the page
888	* flags appropriately	888	* flags appropriately
889	*/	889	*/
890	void page_endio(struct page *page, int rw, int err)	890	void page_endio(struct page *page, int op, int err)
891	{	891	{
892	if (rw == READ) {	892	if (!op_is_write(op)) {
893	if (!err) {	893	if (!err) {
894	SetPageUptodate(page);	894	SetPageUptodate(page);
895	} else {	895	} else {
@@ -897,7 +897,7 @@ void page_endio(struct page *page, int rw, int err) · 1 unmodified line
897	SetPageError(page);	897	SetPageError(page);
898	}	898	}
899	unlock_page(page);	899	unlock_page(page);
900	} else { /* rw == WRITE */	900	} else {
901	if (err) {	901	if (err) {
902	SetPageError(page);	902	SetPageError(page);
903	if (page->mapping)	903	if (page->mapping)

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code