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

Commit 846ade7d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost 

Pull virtio/vhost updates from Michael Tsirkin:
 "virtio, vhost: fixes, cleanups, features

  This includes the disk/cache memory stats for for the virtio balloon,
  as well as multiple fixes and cleanups"

* tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost:
  vhost: don't hold onto file pointer for VHOST_SET_LOG_FD
  vhost: don't hold onto file pointer for VHOST_SET_VRING_ERR
  vhost: don't hold onto file pointer for VHOST_SET_VRING_CALL
  ringtest: ring.c malloc & memset to calloc
  virtio_vop: don't kfree device on register failure
  virtio_pci: don't kfree device on register failure
  virtio: split device_register into device_initialize and device_add
  vhost: remove unused lock check flag in vhost_dev_cleanup()
  vhost: Remove the unused variable.
  virtio_blk: print capacity at probe time
  virtio: make VIRTIO a menuconfig to ease disabling it all
  virtio/ringtest: virtio_ring: fix up need_event math
  virtio/ringtest: fix up need_event math
  virtio: virtio_mmio: make of_device_ids const.
  firmware: Use PTR_ERR_OR_ZERO()
  virtio-mmio: Use PTR_ERR_OR_ZERO()
  vhost/scsi: Improve a size determination in four functions
  virtio_balloon: include disk/file caches memory statistics
parents 977e4152 d25cc43c

drivers/block/virtio_blk.c

+15 −17
Original line number Diff line number Diff line
@@ -373,14 +373,12 @@ static ssize_t virtblk_serial_show(struct device *dev, 


static DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);



static void virtblk_config_changed_work(struct work_struct *work)

/* The queue's logical block size must be set before calling this */

static void virtblk_update_capacity(struct virtio_blk *vblk, bool resize)

{

	struct virtio_blk *vblk =

		container_of(work, struct virtio_blk, config_work);

	struct virtio_device *vdev = vblk->vdev;

	struct request_queue *q = vblk->disk->queue;

	char cap_str_2[10], cap_str_10[10];

	char *envp[] = { "RESIZE=1", NULL };

	unsigned long long nblocks;

	u64 capacity;
@@ -402,13 +400,24 @@ static void virtblk_config_changed_work(struct work_struct *work) 
			STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));



	dev_notice(&vdev->dev,

		   "new size: %llu %d-byte logical blocks (%s/%s)\n",

		   "[%s] %s%llu %d-byte logical blocks (%s/%s)\n",

		   vblk->disk->disk_name,

		   resize ? "new size: " : "",

		   nblocks,

		   queue_logical_block_size(q),

		   cap_str_10,

		   cap_str_2);



	set_capacity(vblk->disk, capacity);

}



static void virtblk_config_changed_work(struct work_struct *work)

{

	struct virtio_blk *vblk =

		container_of(work, struct virtio_blk, config_work);

	char *envp[] = { "RESIZE=1", NULL };



	virtblk_update_capacity(vblk, true);

	revalidate_disk(vblk->disk);

	kobject_uevent_env(&disk_to_dev(vblk->disk)->kobj, KOBJ_CHANGE, envp);

}
@@ -621,7 +630,6 @@ static int virtblk_probe(struct virtio_device *vdev) 
	struct request_queue *q;

	int err, index;



	u64 cap;

	u32 v, blk_size, sg_elems, opt_io_size;

	u16 min_io_size;

	u8 physical_block_exp, alignment_offset;
@@ -719,17 +727,6 @@ static int virtblk_probe(struct virtio_device *vdev) 
	if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))

		set_disk_ro(vblk->disk, 1);



	/* Host must always specify the capacity. */

	virtio_cread(vdev, struct virtio_blk_config, capacity, &cap);



	/* If capacity is too big, truncate with warning. */

	if ((sector_t)cap != cap) {

		dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",

			 (unsigned long long)cap);

		cap = (sector_t)-1;

	}

	set_capacity(vblk->disk, cap);



	/* We can handle whatever the host told us to handle. */

	blk_queue_max_segments(q, vblk->sg_elems-2);
@@ -780,6 +777,7 @@ static int virtblk_probe(struct virtio_device *vdev) 
	if (!err && opt_io_size)

		blk_queue_io_opt(q, blk_size * opt_io_size);



	virtblk_update_capacity(vblk, false);

	virtio_device_ready(vdev);



	device_add_disk(&vdev->dev, vblk->disk);

drivers/firmware/qemu_fw_cfg.c

+1 −3
Original line number Diff line number Diff line
@@ -694,10 +694,8 @@ static int fw_cfg_cmdline_set(const char *arg, const struct kernel_param *kp) 
	 */

	fw_cfg_cmdline_dev = platform_device_register_simple("fw_cfg",

					PLATFORM_DEVID_NONE, res, processed);

	if (IS_ERR(fw_cfg_cmdline_dev))

		return PTR_ERR(fw_cfg_cmdline_dev);



	return 0;

	return PTR_ERR_OR_ZERO(fw_cfg_cmdline_dev);

}



static int fw_cfg_cmdline_get(char *buf, const struct kernel_param *kp)

drivers/misc/mic/vop/vop_main.c

+13 −7
Original line number Diff line number Diff line
@@ -452,10 +452,12 @@ static irqreturn_t vop_virtio_intr_handler(int irq, void *data) 


static void vop_virtio_release_dev(struct device *_d)

{

	/*

	 * No need for a release method similar to virtio PCI.

	 * Provide an empty one to avoid getting a warning from core.

	 */

	struct virtio_device *vdev =

			container_of(_d, struct virtio_device, dev);

	struct _vop_vdev *vop_vdev =

			container_of(vdev, struct _vop_vdev, vdev);



	kfree(vop_vdev);

}



/*
@@ -466,7 +468,7 @@ static int _vop_add_device(struct mic_device_desc __iomem *d, 
			   unsigned int offset, struct vop_device *vpdev,

			   int dnode)

{

	struct _vop_vdev *vdev;

	struct _vop_vdev *vdev, *reg_dev = NULL;

	int ret;

	u8 type = ioread8(&d->type);
@@ -497,6 +499,7 @@ static int _vop_add_device(struct mic_device_desc __iomem *d, 
	vdev->c2h_vdev_db = ioread8(&vdev->dc->c2h_vdev_db);



	ret = register_virtio_device(&vdev->vdev);

	reg_dev = vdev;

	if (ret) {

		dev_err(_vop_dev(vdev),

			"Failed to register vop device %u type %u\n",
@@ -512,6 +515,9 @@ static int _vop_add_device(struct mic_device_desc __iomem *d, 
free_irq:

	vpdev->hw_ops->free_irq(vpdev, vdev->virtio_cookie, vdev);

kfree:

	if (reg_dev)

		put_device(&vdev->vdev.dev);

	else

		kfree(vdev);

	return ret;

}
@@ -568,7 +574,7 @@ static int _vop_remove_device(struct mic_device_desc __iomem *d, 
		iowrite8(-1, &dc->h2c_vdev_db);

		if (status & VIRTIO_CONFIG_S_DRIVER_OK)

			wait_for_completion(&vdev->reset_done);

		kfree(vdev);

		put_device(&vdev->vdev.dev);

		iowrite8(1, &dc->guest_ack);

		dev_dbg(&vpdev->dev, "%s %d guest_ack %d\n",

			__func__, __LINE__, ioread8(&dc->guest_ack));

drivers/vhost/net.c

+1 −1
Original line number Diff line number Diff line
@@ -1015,7 +1015,7 @@ static int vhost_net_release(struct inode *inode, struct file *f) 
	vhost_net_stop(n, &tx_sock, &rx_sock);

	vhost_net_flush(n);

	vhost_dev_stop(&n->dev);

	vhost_dev_cleanup(&n->dev, false);

	vhost_dev_cleanup(&n->dev);

	vhost_net_vq_reset(n);

	if (tx_sock)

		sockfd_put(tx_sock);

drivers/vhost/scsi.c

+5 −6
Original line number Diff line number Diff line
@@ -586,8 +586,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, 
	sg = cmd->tvc_sgl;

	prot_sg = cmd->tvc_prot_sgl;

	pages = cmd->tvc_upages;

	memset(cmd, 0, sizeof(struct vhost_scsi_cmd));



	memset(cmd, 0, sizeof(*cmd));

	cmd->tvc_sgl = sg;

	cmd->tvc_prot_sgl = prot_sg;

	cmd->tvc_upages = pages;
@@ -1420,7 +1419,7 @@ static int vhost_scsi_release(struct inode *inode, struct file *f) 
	mutex_unlock(&vs->dev.mutex);

	vhost_scsi_clear_endpoint(vs, &t);

	vhost_dev_stop(&vs->dev);

	vhost_dev_cleanup(&vs->dev, false);

	vhost_dev_cleanup(&vs->dev);

	/* Jobs can re-queue themselves in evt kick handler. Do extra flush. */

	vhost_scsi_flush(vs);

	kfree(vs->dev.vqs);
@@ -1725,7 +1724,7 @@ static int vhost_scsi_make_nexus(struct vhost_scsi_tpg *tpg, 
		return -EEXIST;

	}



	tv_nexus = kzalloc(sizeof(struct vhost_scsi_nexus), GFP_KERNEL);

	tv_nexus = kzalloc(sizeof(*tv_nexus), GFP_KERNEL);

	if (!tv_nexus) {

		mutex_unlock(&tpg->tv_tpg_mutex);

		pr_err("Unable to allocate struct vhost_scsi_nexus\n");
@@ -1926,7 +1925,7 @@ vhost_scsi_make_tpg(struct se_wwn *wwn, 
	if (kstrtou16(name + 5, 10, &tpgt) || tpgt >= VHOST_SCSI_MAX_TARGET)

		return ERR_PTR(-EINVAL);



	tpg = kzalloc(sizeof(struct vhost_scsi_tpg), GFP_KERNEL);

	tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);

	if (!tpg) {

		pr_err("Unable to allocate struct vhost_scsi_tpg");

		return ERR_PTR(-ENOMEM);
@@ -1980,7 +1979,7 @@ vhost_scsi_make_tport(struct target_fabric_configfs *tf, 
	/* if (vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)

		return ERR_PTR(-EINVAL); */



	tport = kzalloc(sizeof(struct vhost_scsi_tport), GFP_KERNEL);

	tport = kzalloc(sizeof(*tport), GFP_KERNEL);

	if (!tport) {

		pr_err("Unable to allocate struct vhost_scsi_tport");

		return ERR_PTR(-ENOMEM);