Merge branch 'for-3.16/core' of git://git.kernel.dk/linux-block into next

!Efs/mpage.c

!Efs/namei.c

!Efs/buffer.c

!Efs/bio.c

!Eblock/bio.c

!Efs/seq_file.c

!Efs/filesystems.c

!Efs/fs-writeback.c

# Makefile for the kernel block layer

#

obj-$(CONFIG_BLOCK) := elevator.o blk-core.o blk-tag.o blk-sysfs.o \

obj-$(CONFIG_BLOCK) := bio.o elevator.o blk-core.o blk-tag.o blk-sysfs.o \

			blk-flush.o blk-settings.o blk-ioc.o blk-map.o \

			blk-exec.o blk-merge.o blk-softirq.o blk-timeout.o \

			blk-iopoll.o blk-lib.o blk-mq.o blk-mq-tag.o \

			blk-mq-sysfs.o blk-mq-cpu.o blk-mq-cpumap.o ioctl.o \

			genhd.o scsi_ioctl.o partition-generic.o partitions/

			genhd.o scsi_ioctl.o partition-generic.o ioprio.o \

			partitions/

obj-$(CONFIG_BOUNCE)	+= bounce.o

obj-$(CONFIG_BLK_DEV_BSG)	+= bsg.o

obj-$(CONFIG_BLK_DEV_BSGLIB)	+= bsg-lib.o

obj-$(CONFIG_BLK_CGROUP)	+= blk-cgroup.o

obj-$(CONFIG_BLOCK_COMPAT)	+= compat_ioctl.o

obj-$(CONFIG_BLK_DEV_INTEGRITY)	+= blk-integrity.o

obj-$(CONFIG_BLK_CMDLINE_PARSER)	+= cmdline-parser.o

obj-$(CONFIG_BLK_DEV_INTEGRITY) += bio-integrity.o

	if (!bs->bio_integrity_pool)

		return -1;

	bs->bvec_integrity_pool = biovec_create_pool(bs, pool_size);

	bs->bvec_integrity_pool = biovec_create_pool(pool_size);

	if (!bs->bvec_integrity_pool) {

		mempool_destroy(bs->bio_integrity_pool);

		return -1;

/**

 * bio_chain - chain bio completions

 * @bio: the target bio

 * @parent: the @bio's parent bio

 *

 * The caller won't have a bi_end_io called when @bio completes - instead,

 * @parent's bi_end_io won't be called until both @parent and @bio have

	bio->bi_private = bmd;

}

static struct bio_map_data *bio_alloc_map_data(int nr_segs,

					       unsigned int iov_count,

static struct bio_map_data *bio_alloc_map_data(unsigned int iov_count,

					       gfp_t gfp_mask)

{

	if (iov_count > UIO_MAXIOV)

	if (offset)

		nr_pages++;

	bmd = bio_alloc_map_data(nr_pages, iov_count, gfp_mask);

	bmd = bio_alloc_map_data(iov_count, gfp_mask);

	if (!bmd)

		return ERR_PTR(-ENOMEM);

 * create memory pools for biovec's in a bio_set.

 * use the global biovec slabs created for general use.

 */

mempool_t *biovec_create_pool(struct bio_set *bs, int pool_entries)

mempool_t *biovec_create_pool(int pool_entries)

{

	struct biovec_slab *bp = bvec_slabs + BIOVEC_MAX_IDX;

	if (!bs->bio_pool)

		goto bad;

	bs->bvec_pool = biovec_create_pool(bs, pool_size);

	bs->bvec_pool = biovec_create_pool(pool_size);

	if (!bs->bvec_pool)

		goto bad;

	printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",

	       (unsigned long long)blk_rq_pos(rq),

	       blk_rq_sectors(rq), blk_rq_cur_sectors(rq));

	printk(KERN_INFO "  bio %p, biotail %p, buffer %p, len %u\n",

	       rq->bio, rq->biotail, rq->buffer, blk_rq_bytes(rq));

	printk(KERN_INFO "  bio %p, biotail %p, len %u\n",

	       rq->bio, rq->biotail, blk_rq_bytes(rq));

	if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {

		printk(KERN_INFO "  cdb: ");

		struct blk_mq_hw_ctx *hctx;

		int i;

		queue_for_each_hw_ctx(q, hctx, i)

			cancel_delayed_work_sync(&hctx->delayed_work);

		queue_for_each_hw_ctx(q, hctx, i) {

			cancel_delayed_work_sync(&hctx->run_work);

			cancel_delayed_work_sync(&hctx->delay_work);

		}

	} else {

		cancel_delayed_work_sync(&q->delay_work);

	}

	if (!q)

		return NULL;

	if (percpu_counter_init(&q->mq_usage_counter, 0))

		goto fail_q;

	q->id = ida_simple_get(&blk_queue_ida, 0, 0, gfp_mask);

	if (q->id < 0)

		goto fail_c;

		goto fail_q;

	q->backing_dev_info.ra_pages =

			(VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;

	bdi_destroy(&q->backing_dev_info);

fail_id:

	ida_simple_remove(&blk_queue_ida, q->id);

fail_c:

	percpu_counter_destroy(&q->mq_usage_counter);

fail_q:

	kmem_cache_free(blk_requestq_cachep, q);

	return NULL;

		__freed_request(rl, sync ^ 1);

}

int blk_update_nr_requests(struct request_queue *q, unsigned int nr)

{

	struct request_list *rl;

	spin_lock_irq(q->queue_lock);

	q->nr_requests = nr;

	blk_queue_congestion_threshold(q);

	/* congestion isn't cgroup aware and follows root blkcg for now */

	rl = &q->root_rl;

	if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q))

		blk_set_queue_congested(q, BLK_RW_SYNC);

	else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q))

		blk_clear_queue_congested(q, BLK_RW_SYNC);

	if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q))

		blk_set_queue_congested(q, BLK_RW_ASYNC);

	else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q))

		blk_clear_queue_congested(q, BLK_RW_ASYNC);

	blk_queue_for_each_rl(rl, q) {

		if (rl->count[BLK_RW_SYNC] >= q->nr_requests) {

			blk_set_rl_full(rl, BLK_RW_SYNC);

		} else {

			blk_clear_rl_full(rl, BLK_RW_SYNC);

			wake_up(&rl->wait[BLK_RW_SYNC]);

		}

		if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) {

			blk_set_rl_full(rl, BLK_RW_ASYNC);

		} else {

			blk_clear_rl_full(rl, BLK_RW_ASYNC);

			wake_up(&rl->wait[BLK_RW_ASYNC]);

		}

	}

	spin_unlock_irq(q->queue_lock);

	return 0;

}

/*

 * Determine if elevator data should be initialized when allocating the

 * request associated with @bio.

struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)

{

	if (q->mq_ops)

		return blk_mq_alloc_request(q, rw, gfp_mask);

		return blk_mq_alloc_request(q, rw, gfp_mask, false);

	else

		return blk_old_get_request(q, rw, gfp_mask);

}

static void part_round_stats_single(int cpu, struct hd_struct *part,

				    unsigned long now)

{

	int inflight;

	if (now == part->stamp)

		return;

	if (part_in_flight(part)) {

	inflight = part_in_flight(part);

	if (inflight) {

		__part_stat_add(cpu, part, time_in_queue,

				part_in_flight(part) * (now - part->stamp));

				inflight * (now - part->stamp));

		__part_stat_add(cpu, part, io_ticks, (now - part->stamp));

	}

	part->stamp = now;

	rq->__data_len = rq->resid_len = len;

	rq->nr_phys_segments = 1;

	rq->buffer = bio_data(bio);

}

EXPORT_SYMBOL_GPL(blk_add_request_payload);

	bio->bi_next = req->bio;

	req->bio = bio;

	/*

	 * may not be valid. if the low level driver said

	 * it didn't need a bounce buffer then it better

	 * not touch req->buffer either...

	 */

	req->buffer = bio_data(bio);

	req->__sector = bio->bi_iter.bi_sector;

	req->__data_len += bio->bi_iter.bi_size;

	req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));

 * added on the elevator at this point.  In addition, we don't have

 * reliable access to the elevator outside queue lock.  Only check basic

 * merging parameters without querying the elevator.

 *

 * Caller must ensure !blk_queue_nomerges(q) beforehand.

 */

bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,

			    unsigned int *request_count)

	bool ret = false;

	struct list_head *plug_list;

	if (blk_queue_nomerges(q))

		goto out;

	plug = current->plug;

	if (!plug)

		goto out;

	 * Check if we can merge with the plugged list before grabbing

	 * any locks.

	 */

	if (blk_attempt_plug_merge(q, bio, &request_count))

	if (!blk_queue_nomerges(q) &&

	    blk_attempt_plug_merge(q, bio, &request_count))

		return;

	spin_lock_irq(q->queue_lock);

	struct dentry *dir = fault_create_debugfs_attr("fail_make_request",

						NULL, &fail_make_request);

	return IS_ERR(dir) ? PTR_ERR(dir) : 0;

	return PTR_ERR_OR_ZERO(dir);

}

late_initcall(fail_make_request_debugfs);

	}

	req->__data_len -= total_bytes;

	req->buffer = bio_data(req->bio);

	/* update sector only for requests with clear definition of sector */

	if (req->cmd_type == REQ_TYPE_FS)

/*

 * queue lock must be held

 */

static void blk_finish_request(struct request *req, int error)

void blk_finish_request(struct request *req, int error)

{

	if (blk_rq_tagged(req))

		blk_queue_end_tag(req->q, req);

		__blk_put_request(req->q, req);

	}

}

EXPORT_SYMBOL(blk_finish_request);

/**

 * blk_end_bidi_request - Complete a bidi request

	/* Bit 0 (R/W) is identical in rq->cmd_flags and bio->bi_rw */

	rq->cmd_flags |= bio->bi_rw & REQ_WRITE;

	if (bio_has_data(bio)) {

	if (bio_has_data(bio))

		rq->nr_phys_segments = bio_phys_segments(q, bio);

		rq->buffer = bio_data(bio);

	}

	rq->__data_len = bio->bi_iter.bi_size;

	rq->bio = rq->biotail = bio;

/*

 * Copy attributes of the original request to the clone request.

 * The actual data parts (e.g. ->cmd, ->buffer, ->sense) are not copied.

 * The actual data parts (e.g. ->cmd, ->sense) are not copied.

 */

static void __blk_rq_prep_clone(struct request *dst, struct request *src)

{

 *

 * Description:

 *     Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq.

 *     The actual data parts of @rq_src (e.g. ->cmd, ->buffer, ->sense)

 *     The actual data parts of @rq_src (e.g. ->cmd, ->sense)

 *     are not copied, and copying such parts is the caller's responsibility.

 *     Also, pages which the original bios are pointing to are not copied

 *     and the cloned bios just point same pages.

}

EXPORT_SYMBOL_GPL(blk_rq_prep_clone);

int kblockd_schedule_work(struct request_queue *q, struct work_struct *work)

int kblockd_schedule_work(struct work_struct *work)

{

	return queue_work(kblockd_workqueue, work);

}

EXPORT_SYMBOL(kblockd_schedule_work);

int kblockd_schedule_delayed_work(struct request_queue *q,

			struct delayed_work *dwork, unsigned long delay)

int kblockd_schedule_delayed_work(struct delayed_work *dwork,

				  unsigned long delay)

{

	return queue_delayed_work(kblockd_workqueue, dwork, delay);

}

EXPORT_SYMBOL(kblockd_schedule_delayed_work);

#define PLUG_MAGIC	0x91827364

int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork,

				     unsigned long delay)

{

	return queue_delayed_work_on(cpu, kblockd_workqueue, dwork, delay);

}

EXPORT_SYMBOL(kblockd_schedule_delayed_work_on);

/**

 * blk_start_plug - initialize blk_plug and track it inside the task_struct

{

	struct task_struct *tsk = current;

	plug->magic = PLUG_MAGIC;

	INIT_LIST_HEAD(&plug->list);

	INIT_LIST_HEAD(&plug->mq_list);

	INIT_LIST_HEAD(&plug->cb_list);

	LIST_HEAD(list);

	unsigned int depth;

	BUG_ON(plug->magic != PLUG_MAGIC);

	flush_plug_callbacks(plug, from_schedule);

	if (!list_empty(&plug->mq_list))