Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block (e252f4db) · Commits · e / devices / android_kernel_sony_msm8998

block/blk-core.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1770,8 +1770,6 @@ static void end_that_request_last(struct request *req, int error)
	{		{
	struct gendisk *disk = req->rq_disk;		struct gendisk *disk = req->rq_disk;

	blk_delete_timer(req);

	if (blk_rq_tagged(req))		if (blk_rq_tagged(req))
	blk_queue_end_tag(req->q, req);		blk_queue_end_tag(req->q, req);

	@@ -1781,6 +1779,8 @@ static void end_that_request_last(struct request *req, int error)
	if (unlikely(laptop_mode) && blk_fs_request(req))		if (unlikely(laptop_mode) && blk_fs_request(req))
	laptop_io_completion();		laptop_io_completion();

			blk_delete_timer(req);

	/*		/*
	* Account IO completion. bar_rq isn't accounted as a normal		* Account IO completion. bar_rq isn't accounted as a normal
	* IO on queueing nor completion. Accounting the containing		* IO on queueing nor completion. Accounting the containing

block/blk-merge.c

+0 −21

Original line number	Original line	Diff line number	Diff line
	@@ -222,27 +222,6 @@ new_segment:
	}		}
	EXPORT_SYMBOL(blk_rq_map_sg);		EXPORT_SYMBOL(blk_rq_map_sg);

	static inline int ll_new_mergeable(struct request_queue *q,
	struct request *req,
	struct bio *bio)
	{
	int nr_phys_segs = bio_phys_segments(q, bio);

	if (req->nr_phys_segments + nr_phys_segs > q->max_phys_segments) {
	req->cmd_flags \|= REQ_NOMERGE;
	if (req == q->last_merge)
	q->last_merge = NULL;
	return 0;
	}

	/*
	* A hw segment is just getting larger, bump just the phys
	* counter.
	*/
	req->nr_phys_segments += nr_phys_segs;
	return 1;
	}

	static inline int ll_new_hw_segment(struct request_queue *q,		static inline int ll_new_hw_segment(struct request_queue *q,
	struct request *req,		struct request *req,
	struct bio *bio)		struct bio *bio)

block/blk-timeout.c

+3 −17

Original line number	Original line	Diff line number	Diff line
	@@ -75,14 +75,7 @@ void blk_delete_timer(struct request *req)
	{		{
	struct request_queue *q = req->q;		struct request_queue *q = req->q;

	/*
	* Nothing to detach
	*/
	if (!q->rq_timed_out_fn \|\| !req->deadline)
	return;

	list_del_init(&req->timeout_list);		list_del_init(&req->timeout_list);

	if (list_empty(&q->timeout_list))		if (list_empty(&q->timeout_list))
	del_timer(&q->timeout);		del_timer(&q->timeout);
	}		}
	@@ -142,7 +135,7 @@ void blk_rq_timed_out_timer(unsigned long data)
	}		}

	if (next_set && !list_empty(&q->timeout_list))		if (next_set && !list_empty(&q->timeout_list))
	mod_timer(&q->timeout, round_jiffies(next));		mod_timer(&q->timeout, round_jiffies_up(next));

	spin_unlock_irqrestore(q->queue_lock, flags);		spin_unlock_irqrestore(q->queue_lock, flags);
	}		}
	@@ -198,17 +191,10 @@ void blk_add_timer(struct request *req)

	/*		/*
	* If the timer isn't already pending or this timeout is earlier		* If the timer isn't already pending or this timeout is earlier
	* than an existing one, modify the timer. Round to next nearest		* than an existing one, modify the timer. Round up to next nearest
	* second.		* second.
	*/		*/
	expiry = round_jiffies(req->deadline);		expiry = round_jiffies_up(req->deadline);

	/*
	* We use ->deadline == 0 to detect whether a timer was added or
	* not, so just increase to next jiffy for that specific case
	*/
	if (unlikely(!req->deadline))
	req->deadline = 1;

	if (!timer_pending(&q->timeout) \|\|		if (!timer_pending(&q->timeout) \|\|
	time_before(expiry, q->timeout.expires))		time_before(expiry, q->timeout.expires))

block/elevator.c

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -773,12 +773,6 @@ struct request elv_next_request(struct request_queue q)
	*/		*/
	rq->cmd_flags \|= REQ_STARTED;		rq->cmd_flags \|= REQ_STARTED;
	blk_add_trace_rq(q, rq, BLK_TA_ISSUE);		blk_add_trace_rq(q, rq, BLK_TA_ISSUE);

	/*
	* We are now handing the request to the hardware,
	* add the timeout handler
	*/
	blk_add_timer(rq);
	}		}

	if (!q->boundary_rq \|\| q->boundary_rq == rq) {		if (!q->boundary_rq \|\| q->boundary_rq == rq) {
	@@ -850,6 +844,12 @@ void elv_dequeue_request(struct request_queue q, struct request rq)
	*/		*/
	if (blk_account_rq(rq))		if (blk_account_rq(rq))
	q->in_flight++;		q->in_flight++;

			/*
			* We are now handing the request to the hardware, add the
			* timeout handler.
			*/
			blk_add_timer(rq);
	}		}
	EXPORT_SYMBOL(elv_dequeue_request);		EXPORT_SYMBOL(elv_dequeue_request);

fs/block_dev.c

+11 −12

Original line number	Original line	Diff line number	Diff line
	@@ -986,7 +986,6 @@ static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
	static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)		static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
	{		{
	struct gendisk *disk;		struct gendisk *disk;
	struct hd_struct *part = NULL;
	int ret;		int ret;
	int partno;		int partno;
	int perm = 0;		int perm = 0;
	@@ -1004,24 +1003,25 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
	return ret;		return ret;
	}		}

	ret = -ENXIO;

	lock_kernel();		lock_kernel();

			ret = -ENXIO;
	disk = get_gendisk(bdev->bd_dev, &partno);		disk = get_gendisk(bdev->bd_dev, &partno);
	if (!disk)		if (!disk)
	goto out_unlock_kernel;		goto out_unlock_kernel;
	part = disk_get_part(disk, partno);
	if (!part)
	goto out_unlock_kernel;

	mutex_lock_nested(&bdev->bd_mutex, for_part);		mutex_lock_nested(&bdev->bd_mutex, for_part);
	if (!bdev->bd_openers) {		if (!bdev->bd_openers) {
	bdev->bd_disk = disk;		bdev->bd_disk = disk;
	bdev->bd_part = part;
	bdev->bd_contains = bdev;		bdev->bd_contains = bdev;
	if (!partno) {		if (!partno) {
	struct backing_dev_info *bdi;		struct backing_dev_info *bdi;

			ret = -ENXIO;
			bdev->bd_part = disk_get_part(disk, partno);
			if (!bdev->bd_part)
			goto out_clear;

	if (disk->fops->open) {		if (disk->fops->open) {
	ret = disk->fops->open(bdev, mode);		ret = disk->fops->open(bdev, mode);
	if (ret)		if (ret)
	@@ -1049,18 +1049,17 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
	bdev->bd_contains = whole;		bdev->bd_contains = whole;
	bdev->bd_inode->i_data.backing_dev_info =		bdev->bd_inode->i_data.backing_dev_info =
	whole->bd_inode->i_data.backing_dev_info;		whole->bd_inode->i_data.backing_dev_info;
			bdev->bd_part = disk_get_part(disk, partno);
	if (!(disk->flags & GENHD_FL_UP) \|\|		if (!(disk->flags & GENHD_FL_UP) \|\|
	!part \|\| !part->nr_sects) {		!bdev->bd_part \|\| !bdev->bd_part->nr_sects) {
	ret = -ENXIO;		ret = -ENXIO;
	goto out_clear;		goto out_clear;
	}		}
	bd_set_size(bdev, (loff_t)part->nr_sects << 9);		bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
	}		}
	} else {		} else {
	disk_put_part(part);
	put_disk(disk);		put_disk(disk);
	module_put(disk->fops->owner);		module_put(disk->fops->owner);
	part = NULL;
	disk = NULL;		disk = NULL;
	if (bdev->bd_contains == bdev) {		if (bdev->bd_contains == bdev) {
	if (bdev->bd_disk->fops->open) {		if (bdev->bd_disk->fops->open) {
	@@ -1080,6 +1079,7 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
	return 0;		return 0;

	out_clear:		out_clear:
			disk_put_part(bdev->bd_part);
	bdev->bd_disk = NULL;		bdev->bd_disk = NULL;
	bdev->bd_part = NULL;		bdev->bd_part = NULL;
	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;		bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
	@@ -1091,7 +1091,6 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
	out_unlock_kernel:		out_unlock_kernel:
	unlock_kernel();		unlock_kernel();

	disk_put_part(part);
	if (disk)		if (disk)
	module_put(disk->fops->owner);		module_put(disk->fops->owner);
	put_disk(disk);		put_disk(disk);