Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 984bc960 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

* 'for-linus' of git://git.kernel.dk/linux-2.6-block:
  block: Don't count_vm_events for discard bio in submit_bio.
  cfq: fix recursive call in cfq_blkiocg_update_completion_stats()
  cfq-iosched: Fixed boot warning with BLK_CGROUP=y and CFQ_GROUP_IOSCHED=n
  cfq: Don't allow queue merges for queues that have no process references
  block: fix DISCARD_BARRIER requests
  cciss: set SCSI max cmd len to 16, as default is wrong
  cpqarray: fix two more wrong section type
  cpqarray: fix wrong __init type on pci probe function
  drbd: Fixed a race between disk-attach and unexpected state changes
  writeback: fix pin_sb_for_writeback
  writeback: add missing requeue_io in writeback_inodes_wb
  writeback: simplify and split bdi_start_writeback
  writeback: simplify wakeup_flusher_threads
  writeback: fix writeback_inodes_wb from writeback_inodes_sb
  writeback: enforce s_umount locking in writeback_inodes_sb
  writeback: queue work on stack in writeback_inodes_sb
  writeback: fix writeback completion notifications
parents 57439f87 1b99973f

block/blk-core.c

+3 −6
Original line number Diff line number Diff line
@@ -1149,13 +1149,10 @@ void init_request_from_bio(struct request *req, struct bio *bio) 
	else

		req->cmd_flags |= bio->bi_rw & REQ_FAILFAST_MASK;



	if (unlikely(bio_rw_flagged(bio, BIO_RW_DISCARD))) {

	if (bio_rw_flagged(bio, BIO_RW_DISCARD))

		req->cmd_flags |= REQ_DISCARD;

	if (bio_rw_flagged(bio, BIO_RW_BARRIER))

			req->cmd_flags |= REQ_SOFTBARRIER;

	} else if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER)))

		req->cmd_flags |= REQ_HARDBARRIER;



	if (bio_rw_flagged(bio, BIO_RW_SYNCIO))

		req->cmd_flags |= REQ_RW_SYNC;

	if (bio_rw_flagged(bio, BIO_RW_META))
@@ -1586,7 +1583,7 @@ void submit_bio(int rw, struct bio *bio) 
	 * If it's a regular read/write or a barrier with data attached,

	 * go through the normal accounting stuff before submission.

	 */

	if (bio_has_data(bio)) {

	if (bio_has_data(bio) && !(rw & (1 << BIO_RW_DISCARD))) {

		if (rw & WRITE) {

			count_vm_events(PGPGOUT, count);

		} else {

block/cfq-iosched.c

+38 −29
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
#include <linux/rbtree.h>

#include <linux/ioprio.h>

#include <linux/blktrace_api.h>

#include "blk-cgroup.h"

#include "cfq.h"



/*

 * tunables
@@ -879,7 +879,7 @@ cfq_group_service_tree_del(struct cfq_data *cfqd, struct cfq_group *cfqg) 
	if (!RB_EMPTY_NODE(&cfqg->rb_node))

		cfq_rb_erase(&cfqg->rb_node, st);

	cfqg->saved_workload_slice = 0;

	blkiocg_update_dequeue_stats(&cfqg->blkg, 1);

	cfq_blkiocg_update_dequeue_stats(&cfqg->blkg, 1);

}



static inline unsigned int cfq_cfqq_slice_usage(struct cfq_queue *cfqq)
@@ -939,8 +939,8 @@ static void cfq_group_served(struct cfq_data *cfqd, struct cfq_group *cfqg, 


	cfq_log_cfqg(cfqd, cfqg, "served: vt=%llu min_vt=%llu", cfqg->vdisktime,

					st->min_vdisktime);

	blkiocg_update_timeslice_used(&cfqg->blkg, used_sl);

	blkiocg_set_start_empty_time(&cfqg->blkg);

	cfq_blkiocg_update_timeslice_used(&cfqg->blkg, used_sl);

	cfq_blkiocg_set_start_empty_time(&cfqg->blkg);

}



#ifdef CONFIG_CFQ_GROUP_IOSCHED
@@ -995,7 +995,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create) 


	/* Add group onto cgroup list */

	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);

	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,

	cfq_blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,

					MKDEV(major, minor));

	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
@@ -1079,7 +1079,7 @@ static void cfq_release_cfq_groups(struct cfq_data *cfqd) 
		 * it from cgroup list, then it will take care of destroying

		 * cfqg also.

		 */

		if (!blkiocg_del_blkio_group(&cfqg->blkg))

		if (!cfq_blkiocg_del_blkio_group(&cfqg->blkg))

			cfq_destroy_cfqg(cfqd, cfqg);

	}

}
@@ -1421,10 +1421,10 @@ static void cfq_reposition_rq_rb(struct cfq_queue *cfqq, struct request *rq) 
{

	elv_rb_del(&cfqq->sort_list, rq);

	cfqq->queued[rq_is_sync(rq)]--;

	blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg, rq_data_dir(rq),

						rq_is_sync(rq));

	cfq_blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg,

					rq_data_dir(rq), rq_is_sync(rq));

	cfq_add_rq_rb(rq);

	blkiocg_update_io_add_stats(&(RQ_CFQG(rq))->blkg,

	cfq_blkiocg_update_io_add_stats(&(RQ_CFQG(rq))->blkg,

			&cfqq->cfqd->serving_group->blkg, rq_data_dir(rq),

			rq_is_sync(rq));

}
@@ -1482,8 +1482,8 @@ static void cfq_remove_request(struct request *rq) 
	cfq_del_rq_rb(rq);



	cfqq->cfqd->rq_queued--;

	blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg, rq_data_dir(rq),

						rq_is_sync(rq));

	cfq_blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg,

					rq_data_dir(rq), rq_is_sync(rq));

	if (rq_is_meta(rq)) {

		WARN_ON(!cfqq->meta_pending);

		cfqq->meta_pending--;
@@ -1518,8 +1518,8 @@ static void cfq_merged_request(struct request_queue *q, struct request *req, 
static void cfq_bio_merged(struct request_queue *q, struct request *req,

				struct bio *bio)

{

	blkiocg_update_io_merged_stats(&(RQ_CFQG(req))->blkg, bio_data_dir(bio),

					cfq_bio_sync(bio));

	cfq_blkiocg_update_io_merged_stats(&(RQ_CFQG(req))->blkg,

					bio_data_dir(bio), cfq_bio_sync(bio));

}



static void
@@ -1539,8 +1539,8 @@ cfq_merged_requests(struct request_queue *q, struct request *rq, 
	if (cfqq->next_rq == next)

		cfqq->next_rq = rq;

	cfq_remove_request(next);

	blkiocg_update_io_merged_stats(&(RQ_CFQG(rq))->blkg, rq_data_dir(next),

					rq_is_sync(next));

	cfq_blkiocg_update_io_merged_stats(&(RQ_CFQG(rq))->blkg,

					rq_data_dir(next), rq_is_sync(next));

}



static int cfq_allow_merge(struct request_queue *q, struct request *rq,
@@ -1571,7 +1571,7 @@ static int cfq_allow_merge(struct request_queue *q, struct request *rq, 
static inline void cfq_del_timer(struct cfq_data *cfqd, struct cfq_queue *cfqq)

{

	del_timer(&cfqd->idle_slice_timer);

	blkiocg_update_idle_time_stats(&cfqq->cfqg->blkg);

	cfq_blkiocg_update_idle_time_stats(&cfqq->cfqg->blkg);

}



static void __cfq_set_active_queue(struct cfq_data *cfqd,
@@ -1580,7 +1580,7 @@ static void __cfq_set_active_queue(struct cfq_data *cfqd, 
	if (cfqq) {

		cfq_log_cfqq(cfqd, cfqq, "set_active wl_prio:%d wl_type:%d",

				cfqd->serving_prio, cfqd->serving_type);

		blkiocg_update_avg_queue_size_stats(&cfqq->cfqg->blkg);

		cfq_blkiocg_update_avg_queue_size_stats(&cfqq->cfqg->blkg);

		cfqq->slice_start = 0;

		cfqq->dispatch_start = jiffies;

		cfqq->allocated_slice = 0;
@@ -1911,7 +1911,7 @@ static void cfq_arm_slice_timer(struct cfq_data *cfqd) 
	sl = cfqd->cfq_slice_idle;



	mod_timer(&cfqd->idle_slice_timer, jiffies + sl);

	blkiocg_update_set_idle_time_stats(&cfqq->cfqg->blkg);

	cfq_blkiocg_update_set_idle_time_stats(&cfqq->cfqg->blkg);

	cfq_log_cfqq(cfqd, cfqq, "arm_idle: %lu", sl);

}
@@ -1931,7 +1931,7 @@ static void cfq_dispatch_insert(struct request_queue *q, struct request *rq) 
	elv_dispatch_sort(q, rq);



	cfqd->rq_in_flight[cfq_cfqq_sync(cfqq)]++;

	blkiocg_update_dispatch_stats(&cfqq->cfqg->blkg, blk_rq_bytes(rq),

	cfq_blkiocg_update_dispatch_stats(&cfqq->cfqg->blkg, blk_rq_bytes(rq),

					rq_data_dir(rq), rq_is_sync(rq));

}
@@ -1986,6 +1986,15 @@ static void cfq_setup_merge(struct cfq_queue *cfqq, struct cfq_queue *new_cfqq) 
	int process_refs, new_process_refs;

	struct cfq_queue *__cfqq;



	/*

	 * If there are no process references on the new_cfqq, then it is

	 * unsafe to follow the ->new_cfqq chain as other cfqq's in the

	 * chain may have dropped their last reference (not just their

	 * last process reference).

	 */

	if (!cfqq_process_refs(new_cfqq))

		return;



	/* Avoid a circular list and skip interim queue merges */

	while ((__cfqq = new_cfqq->new_cfqq)) {

		if (__cfqq == cfqq)
@@ -1994,17 +2003,17 @@ static void cfq_setup_merge(struct cfq_queue *cfqq, struct cfq_queue *new_cfqq) 
	}



	process_refs = cfqq_process_refs(cfqq);

	new_process_refs = cfqq_process_refs(new_cfqq);

	/*

	 * If the process for the cfqq has gone away, there is no

	 * sense in merging the queues.

	 */

	if (process_refs == 0)

	if (process_refs == 0 || new_process_refs == 0)

		return;



	/*

	 * Merge in the direction of the lesser amount of work.

	 */

	new_process_refs = cfqq_process_refs(new_cfqq);

	if (new_process_refs >= process_refs) {

		cfqq->new_cfqq = new_cfqq;

		atomic_add(process_refs, &new_cfqq->ref);
@@ -3248,7 +3257,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq, 
				cfq_clear_cfqq_wait_request(cfqq);

				__blk_run_queue(cfqd->queue);

			} else {

				blkiocg_update_idle_time_stats(

				cfq_blkiocg_update_idle_time_stats(

						&cfqq->cfqg->blkg);

				cfq_mark_cfqq_must_dispatch(cfqq);

			}
@@ -3276,7 +3285,7 @@ static void cfq_insert_request(struct request_queue *q, struct request *rq) 
	rq_set_fifo_time(rq, jiffies + cfqd->cfq_fifo_expire[rq_is_sync(rq)]);

	list_add_tail(&rq->queuelist, &cfqq->fifo);

	cfq_add_rq_rb(rq);

	blkiocg_update_io_add_stats(&(RQ_CFQG(rq))->blkg,

	cfq_blkiocg_update_io_add_stats(&(RQ_CFQG(rq))->blkg,

			&cfqd->serving_group->blkg, rq_data_dir(rq),

			rq_is_sync(rq));

	cfq_rq_enqueued(cfqd, cfqq, rq);
@@ -3364,9 +3373,9 @@ static void cfq_completed_request(struct request_queue *q, struct request *rq) 
	WARN_ON(!cfqq->dispatched);

	cfqd->rq_in_driver--;

	cfqq->dispatched--;

	blkiocg_update_completion_stats(&cfqq->cfqg->blkg, rq_start_time_ns(rq),

			rq_io_start_time_ns(rq), rq_data_dir(rq),

			rq_is_sync(rq));

	cfq_blkiocg_update_completion_stats(&cfqq->cfqg->blkg,

			rq_start_time_ns(rq), rq_io_start_time_ns(rq),

			rq_data_dir(rq), rq_is_sync(rq));



	cfqd->rq_in_flight[cfq_cfqq_sync(cfqq)]--;
@@ -3730,7 +3739,7 @@ static void cfq_exit_queue(struct elevator_queue *e) 


	cfq_put_async_queues(cfqd);

	cfq_release_cfq_groups(cfqd);

	blkiocg_del_blkio_group(&cfqd->root_group.blkg);

	cfq_blkiocg_del_blkio_group(&cfqd->root_group.blkg);



	spin_unlock_irq(q->queue_lock);
@@ -3798,8 +3807,8 @@ static void *cfq_init_queue(struct request_queue *q) 
	 */

	atomic_set(&cfqg->ref, 1);

	rcu_read_lock();

	blkiocg_add_blkio_group(&blkio_root_cgroup, &cfqg->blkg, (void *)cfqd,

					0);

	cfq_blkiocg_add_blkio_group(&blkio_root_cgroup, &cfqg->blkg,

					(void *)cfqd, 0);

	rcu_read_unlock();

#endif

	/*

block/cfq.h

0 → 100644
+115 −0
Original line number Diff line number Diff line 
#ifndef _CFQ_H

#define _CFQ_H

#include "blk-cgroup.h"



#ifdef CONFIG_CFQ_GROUP_IOSCHED

static inline void cfq_blkiocg_update_io_add_stats(struct blkio_group *blkg,

	struct blkio_group *curr_blkg, bool direction, bool sync)

{

	blkiocg_update_io_add_stats(blkg, curr_blkg, direction, sync);

}



static inline void cfq_blkiocg_update_dequeue_stats(struct blkio_group *blkg,

			unsigned long dequeue)

{

	blkiocg_update_dequeue_stats(blkg, dequeue);

}



static inline void cfq_blkiocg_update_timeslice_used(struct blkio_group *blkg,

			unsigned long time)

{

	blkiocg_update_timeslice_used(blkg, time);

}



static inline void cfq_blkiocg_set_start_empty_time(struct blkio_group *blkg)

{

	blkiocg_set_start_empty_time(blkg);

}



static inline void cfq_blkiocg_update_io_remove_stats(struct blkio_group *blkg,

				bool direction, bool sync)

{

	blkiocg_update_io_remove_stats(blkg, direction, sync);

}



static inline void cfq_blkiocg_update_io_merged_stats(struct blkio_group *blkg,

		bool direction, bool sync)

{

	blkiocg_update_io_merged_stats(blkg, direction, sync);

}



static inline void cfq_blkiocg_update_idle_time_stats(struct blkio_group *blkg)

{

	blkiocg_update_idle_time_stats(blkg);

}



static inline void

cfq_blkiocg_update_avg_queue_size_stats(struct blkio_group *blkg)

{

	blkiocg_update_avg_queue_size_stats(blkg);

}



static inline void

cfq_blkiocg_update_set_idle_time_stats(struct blkio_group *blkg)

{

	blkiocg_update_set_idle_time_stats(blkg);

}



static inline void cfq_blkiocg_update_dispatch_stats(struct blkio_group *blkg,

				uint64_t bytes, bool direction, bool sync)

{

	blkiocg_update_dispatch_stats(blkg, bytes, direction, sync);

}



static inline void cfq_blkiocg_update_completion_stats(struct blkio_group *blkg, uint64_t start_time, uint64_t io_start_time, bool direction, bool sync)

{

	blkiocg_update_completion_stats(blkg, start_time, io_start_time,

				direction, sync);

}



static inline void cfq_blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,

			struct blkio_group *blkg, void *key, dev_t dev) {

	blkiocg_add_blkio_group(blkcg, blkg, key, dev);

}



static inline int cfq_blkiocg_del_blkio_group(struct blkio_group *blkg)

{

	return blkiocg_del_blkio_group(blkg);

}



#else /* CFQ_GROUP_IOSCHED */

static inline void cfq_blkiocg_update_io_add_stats(struct blkio_group *blkg,

	struct blkio_group *curr_blkg, bool direction, bool sync) {}



static inline void cfq_blkiocg_update_dequeue_stats(struct blkio_group *blkg,

			unsigned long dequeue) {}



static inline void cfq_blkiocg_update_timeslice_used(struct blkio_group *blkg,

			unsigned long time) {}

static inline void cfq_blkiocg_set_start_empty_time(struct blkio_group *blkg) {}

static inline void cfq_blkiocg_update_io_remove_stats(struct blkio_group *blkg,

				bool direction, bool sync) {}

static inline void cfq_blkiocg_update_io_merged_stats(struct blkio_group *blkg,

		bool direction, bool sync) {}

static inline void cfq_blkiocg_update_idle_time_stats(struct blkio_group *blkg)

{

}

static inline void

cfq_blkiocg_update_avg_queue_size_stats(struct blkio_group *blkg) {}



static inline void

cfq_blkiocg_update_set_idle_time_stats(struct blkio_group *blkg) {}



static inline void cfq_blkiocg_update_dispatch_stats(struct blkio_group *blkg,

				uint64_t bytes, bool direction, bool sync) {}

static inline void cfq_blkiocg_update_completion_stats(struct blkio_group *blkg, uint64_t start_time, uint64_t io_start_time, bool direction, bool sync) {}



static inline void cfq_blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,

			struct blkio_group *blkg, void *key, dev_t dev) {}

static inline int cfq_blkiocg_del_blkio_group(struct blkio_group *blkg)

{

	return 0;

}



#endif /* CFQ_GROUP_IOSCHED */

#endif

drivers/block/cciss_scsi.c

+1 −0
Original line number Diff line number Diff line
@@ -861,6 +861,7 @@ cciss_scsi_detect(int ctlr) 
	sh->n_io_port = 0;	// I don't think we use these two...

	sh->this_id = SELF_SCSI_ID;  

	sh->sg_tablesize = hba[ctlr]->maxsgentries;

	sh->max_cmd_len = MAX_COMMAND_SIZE;



	((struct cciss_scsi_adapter_data_t *) 

		hba[ctlr]->scsi_ctlr)->scsi_host = sh;

drivers/block/cpqarray.c

+3 −3
Original line number Diff line number Diff line
@@ -386,7 +386,7 @@ static void __devexit cpqarray_remove_one_eisa (int i) 
}



/* pdev is NULL for eisa */

static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)

static int __devinit cpqarray_register_ctlr( int i, struct pci_dev *pdev)

{

	struct request_queue *q;

	int j;
@@ -503,7 +503,7 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev) 
	return -1;

}



static int __init cpqarray_init_one( struct pci_dev *pdev,

static int __devinit cpqarray_init_one( struct pci_dev *pdev,

	const struct pci_device_id *ent)

{

	int i;
@@ -740,7 +740,7 @@ __setup("smart2=", cpqarray_setup); 
/*

 * Find an EISA controller's signature.  Set up an hba if we find it.

 */

static int __init cpqarray_eisa_detect(void)

static int __devinit cpqarray_eisa_detect(void)

{

	int i=0, j;

	__u32 board_id;