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

Commit e5a8a116 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull block fixes from Jens Axboe:

 - NVMe pull request from Christoph, fixing namespace locking when
   dealing with the effects log, and a rapid add/remove issue (Keith)

 - blktrace tweak, ensuring requests with -1 sectors are shown (Jan)

 - link power management quirk for a Smasung SSD (Hans)

 - m68k nfblock dynamic major number fix (Chengguang)

 - series fixing blk-iolatency inflight counter issue (Liu)

 - ensure that we clear ->private when setting up the aio kiocb (Mike)

 - __find_get_block_slow() rate limit print (Tetsuo)

* tag 'for-linus-20190209' of git://git.kernel.dk/linux-block:
  blk-mq: remove duplicated definition of blk_mq_freeze_queue
  Blk-iolatency: warn on negative inflight IO counter
  blk-iolatency: fix IO hang due to negative inflight counter
  blktrace: Show requests without sector
  fs: ratelimit __find_get_block_slow() failure message.
  m68k: set proper major_num when specifying module param major_num
  libata: Add NOLPM quirk for SAMSUNG MZ7TE512HMHP-000L1 SSD
  nvme-pci: fix rapid add remove sequence
  nvme: lock NS list changes while handling command effects
  aio: initialize kiocb private in case any filesystems expect it.
parents 5610789a 26984841

arch/m68k/emu/nfblock.c

+7 −3
Original line number Diff line number Diff line
@@ -155,18 +155,22 @@ static int __init nfhd_init_one(int id, u32 blocks, u32 bsize) 
static int __init nfhd_init(void)

{

	u32 blocks, bsize;

	int ret;

	int i;



	nfhd_id = nf_get_id("XHDI");

	if (!nfhd_id)

		return -ENODEV;



	major_num = register_blkdev(major_num, "nfhd");

	if (major_num <= 0) {

	ret = register_blkdev(major_num, "nfhd");

	if (ret < 0) {

		pr_warn("nfhd: unable to get major number\n");

		return major_num;

		return ret;

	}



	if (!major_num)

		major_num = ret;



	for (i = NFHD_DEV_OFFSET; i < 24; i++) {

		if (nfhd_get_capacity(i, 0, &blocks, &bsize))

			continue;

block/blk-iolatency.c

+48 −8
Original line number Diff line number Diff line
@@ -72,6 +72,7 @@ 
#include <linux/sched/loadavg.h>

#include <linux/sched/signal.h>

#include <trace/events/block.h>

#include <linux/blk-mq.h>

#include "blk-rq-qos.h"

#include "blk-stat.h"
@@ -591,6 +592,7 @@ static void blkcg_iolatency_done_bio(struct rq_qos *rqos, struct bio *bio) 
	u64 now = ktime_to_ns(ktime_get());

	bool issue_as_root = bio_issue_as_root_blkg(bio);

	bool enabled = false;

	int inflight = 0;



	blkg = bio->bi_blkg;

	if (!blkg || !bio_flagged(bio, BIO_TRACKED))
@@ -601,6 +603,9 @@ static void blkcg_iolatency_done_bio(struct rq_qos *rqos, struct bio *bio) 
		return;



	enabled = blk_iolatency_enabled(iolat->blkiolat);

	if (!enabled)

		return;



	while (blkg && blkg->parent) {

		iolat = blkg_to_lat(blkg);

		if (!iolat) {
@@ -609,8 +614,9 @@ static void blkcg_iolatency_done_bio(struct rq_qos *rqos, struct bio *bio) 
		}

		rqw = &iolat->rq_wait;



		atomic_dec(&rqw->inflight);

		if (!enabled || iolat->min_lat_nsec == 0)

		inflight = atomic_dec_return(&rqw->inflight);

		WARN_ON_ONCE(inflight < 0);

		if (iolat->min_lat_nsec == 0)

			goto next;

		iolatency_record_time(iolat, &bio->bi_issue, now,

				      issue_as_root);
@@ -754,10 +760,13 @@ int blk_iolatency_init(struct request_queue *q) 
	return 0;

}



static void iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val)

/*

 * return 1 for enabling iolatency, return -1 for disabling iolatency, otherwise

 * return 0.

 */

static int iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val)

{

	struct iolatency_grp *iolat = blkg_to_lat(blkg);

	struct blk_iolatency *blkiolat = iolat->blkiolat;

	u64 oldval = iolat->min_lat_nsec;



	iolat->min_lat_nsec = val;
@@ -766,9 +775,10 @@ static void iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val) 
				    BLKIOLATENCY_MAX_WIN_SIZE);



	if (!oldval && val)

		atomic_inc(&blkiolat->enabled);

		return 1;

	if (oldval && !val)

		atomic_dec(&blkiolat->enabled);

		return -1;

	return 0;

}



static void iolatency_clear_scaling(struct blkcg_gq *blkg)
@@ -800,6 +810,7 @@ static ssize_t iolatency_set_limit(struct kernfs_open_file *of, char *buf, 
	u64 lat_val = 0;

	u64 oldval;

	int ret;

	int enable = 0;



	ret = blkg_conf_prep(blkcg, &blkcg_policy_iolatency, buf, &ctx);

	if (ret)
@@ -834,7 +845,12 @@ static ssize_t iolatency_set_limit(struct kernfs_open_file *of, char *buf, 
	blkg = ctx.blkg;

	oldval = iolat->min_lat_nsec;



	iolatency_set_min_lat_nsec(blkg, lat_val);

	enable = iolatency_set_min_lat_nsec(blkg, lat_val);

	if (enable) {

		WARN_ON_ONCE(!blk_get_queue(blkg->q));

		blkg_get(blkg);

	}



	if (oldval != iolat->min_lat_nsec) {

		iolatency_clear_scaling(blkg);

	}
@@ -842,6 +858,24 @@ static ssize_t iolatency_set_limit(struct kernfs_open_file *of, char *buf, 
	ret = 0;

out:

	blkg_conf_finish(&ctx);

	if (ret == 0 && enable) {

		struct iolatency_grp *tmp = blkg_to_lat(blkg);

		struct blk_iolatency *blkiolat = tmp->blkiolat;



		blk_mq_freeze_queue(blkg->q);



		if (enable == 1)

			atomic_inc(&blkiolat->enabled);

		else if (enable == -1)

			atomic_dec(&blkiolat->enabled);

		else

			WARN_ON_ONCE(1);



		blk_mq_unfreeze_queue(blkg->q);



		blkg_put(blkg);

		blk_put_queue(blkg->q);

	}

	return ret ?: nbytes;

}
@@ -977,8 +1011,14 @@ static void iolatency_pd_offline(struct blkg_policy_data *pd) 
{

	struct iolatency_grp *iolat = pd_to_lat(pd);

	struct blkcg_gq *blkg = lat_to_blkg(iolat);

	struct blk_iolatency *blkiolat = iolat->blkiolat;

	int ret;



	iolatency_set_min_lat_nsec(blkg, 0);

	ret = iolatency_set_min_lat_nsec(blkg, 0);

	if (ret == 1)

		atomic_inc(&blkiolat->enabled);

	if (ret == -1)

		atomic_dec(&blkiolat->enabled);

	iolatency_clear_scaling(blkg);

}

block/blk-mq.h

+0 −1
Original line number Diff line number Diff line
@@ -36,7 +36,6 @@ struct blk_mq_ctx { 
	struct kobject		kobj;

} ____cacheline_aligned_in_smp;



void blk_mq_freeze_queue(struct request_queue *q);

void blk_mq_free_queue(struct request_queue *q);

int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr);

void blk_mq_wake_waiters(struct request_queue *q);

drivers/ata/libata-core.c

+1 −0
Original line number Diff line number Diff line
@@ -4554,6 +4554,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { 
	{ "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM, },

	{ "SAMSUNG SSD PM830 mSATA *",  "CXM13D1Q", ATA_HORKAGE_NOLPM, },

	{ "SAMSUNG MZ7TD256HAFV-000L9", NULL,       ATA_HORKAGE_NOLPM, },

	{ "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM, },



	/* devices that don't properly handle queued TRIM commands */

	{ "Micron_M500IT_*",		"MU01",	ATA_HORKAGE_NO_NCQ_TRIM |

drivers/nvme/host/core.c

+7 −1
Original line number Diff line number Diff line
@@ -1253,6 +1253,7 @@ static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns, 
	 * effects say only one namespace is affected.

	 */

	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {

		mutex_lock(&ctrl->scan_lock);

		nvme_start_freeze(ctrl);

		nvme_wait_freeze(ctrl);

	}
@@ -1281,8 +1282,10 @@ static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects) 
	 */

	if (effects & NVME_CMD_EFFECTS_LBCC)

		nvme_update_formats(ctrl);

	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK))

	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {

		nvme_unfreeze(ctrl);

		mutex_unlock(&ctrl->scan_lock);

	}

	if (effects & NVME_CMD_EFFECTS_CCC)

		nvme_init_identify(ctrl);

	if (effects & (NVME_CMD_EFFECTS_NIC | NVME_CMD_EFFECTS_NCC))
@@ -3401,6 +3404,7 @@ static void nvme_scan_work(struct work_struct *work) 
	if (nvme_identify_ctrl(ctrl, &id))

		return;



	mutex_lock(&ctrl->scan_lock);

	nn = le32_to_cpu(id->nn);

	if (ctrl->vs >= NVME_VS(1, 1, 0) &&

	    !(ctrl->quirks & NVME_QUIRK_IDENTIFY_CNS)) {
@@ -3409,6 +3413,7 @@ static void nvme_scan_work(struct work_struct *work) 
	}

	nvme_scan_ns_sequential(ctrl, nn);

out_free_id:

	mutex_unlock(&ctrl->scan_lock);

	kfree(id);

	down_write(&ctrl->namespaces_rwsem);

	list_sort(NULL, &ctrl->namespaces, ns_cmp);
@@ -3652,6 +3657,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, 


	ctrl->state = NVME_CTRL_NEW;

	spin_lock_init(&ctrl->lock);

	mutex_init(&ctrl->scan_lock);

	INIT_LIST_HEAD(&ctrl->namespaces);

	init_rwsem(&ctrl->namespaces_rwsem);

	ctrl->dev = dev;