virtio-pmem: Add virtio pmem driver (6e84200c) · Commits · 戴 / test

drivers/nvdimm/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@ obj-$(CONFIG_ND_BTT) += nd_btt.o
		obj-$(CONFIG_ND_BLK) += nd_blk.o
		obj-$(CONFIG_X86_PMEM_LEGACY) += nd_e820.o
		obj-$(CONFIG_OF_PMEM) += of_pmem.o
		obj-$(CONFIG_VIRTIO_PMEM) += virtio_pmem.o nd_virtio.o

		nd_pmem-y := pmem.o

drivers/nvdimm/nd_virtio.c

0 → 100644

+125 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* virtio_pmem.c: Virtio pmem Driver
		*
		* Discovers persistent memory range information
		* from host and provides a virtio based flushing
		* interface.
		*/
		#include "virtio_pmem.h"
		#include "nd.h"

		/* The interrupt handler */
		void virtio_pmem_host_ack(struct virtqueue *vq)
		{
		struct virtio_pmem *vpmem = vq->vdev->priv;
		struct virtio_pmem_request req_data, req_buf;
		unsigned long flags;
		unsigned int len;

		spin_lock_irqsave(&vpmem->pmem_lock, flags);
		while ((req_data = virtqueue_get_buf(vq, &len)) != NULL) {
		req_data->done = true;
		wake_up(&req_data->host_acked);

		if (!list_empty(&vpmem->req_list)) {
		req_buf = list_first_entry(&vpmem->req_list,
		struct virtio_pmem_request, list);
		req_buf->wq_buf_avail = true;
		wake_up(&req_buf->wq_buf);
		list_del(&req_buf->list);
		}
		}
		spin_unlock_irqrestore(&vpmem->pmem_lock, flags);
		}
		EXPORT_SYMBOL_GPL(virtio_pmem_host_ack);

		/* The request submission function */
		static int virtio_pmem_flush(struct nd_region *nd_region)
		{
		struct virtio_device *vdev = nd_region->provider_data;
		struct virtio_pmem *vpmem = vdev->priv;
		struct virtio_pmem_request *req_data;
		struct scatterlist *sgs[2], sg, ret;
		unsigned long flags;
		int err, err1;

		might_sleep();
		req_data = kmalloc(sizeof(*req_data), GFP_KERNEL);
		if (!req_data)
		return -ENOMEM;

		req_data->done = false;
		init_waitqueue_head(&req_data->host_acked);
		init_waitqueue_head(&req_data->wq_buf);
		INIT_LIST_HEAD(&req_data->list);
		req_data->req.type = cpu_to_virtio32(vdev, VIRTIO_PMEM_REQ_TYPE_FLUSH);
		sg_init_one(&sg, &req_data->req, sizeof(req_data->req));
		sgs[0] = &sg;
		sg_init_one(&ret, &req_data->resp.ret, sizeof(req_data->resp));
		sgs[1] = &ret;

		spin_lock_irqsave(&vpmem->pmem_lock, flags);
		/*
		* If virtqueue_add_sgs returns -ENOSPC then req_vq virtual
		* queue does not have free descriptor. We add the request
		* to req_list and wait for host_ack to wake us up when free
		* slots are available.
		*/
		while ((err = virtqueue_add_sgs(vpmem->req_vq, sgs, 1, 1, req_data,
		GFP_ATOMIC)) == -ENOSPC) {

		dev_info(&vdev->dev, "failed to send command to virtio pmem device, no free slots in the virtqueue\n");
		req_data->wq_buf_avail = false;
		list_add_tail(&req_data->list, &vpmem->req_list);
		spin_unlock_irqrestore(&vpmem->pmem_lock, flags);

		/* A host response results in "host_ack" getting called */
		wait_event(req_data->wq_buf, req_data->wq_buf_avail);
		spin_lock_irqsave(&vpmem->pmem_lock, flags);
		}
		err1 = virtqueue_kick(vpmem->req_vq);
		spin_unlock_irqrestore(&vpmem->pmem_lock, flags);
		/*
		* virtqueue_add_sgs failed with error different than -ENOSPC, we can't
		* do anything about that.
		*/
		if (err \|\| !err1) {
		dev_info(&vdev->dev, "failed to send command to virtio pmem device\n");
		err = -EIO;
		} else {
		/* A host repsonse results in "host_ack" getting called */
		wait_event(req_data->host_acked, req_data->done);
		err = virtio32_to_cpu(vdev, req_data->resp.ret);
		}

		kfree(req_data);
		return err;
		};

		/* The asynchronous flush callback function */
		int async_pmem_flush(struct nd_region nd_region, struct bio bio)
		{
		/*
		* Create child bio for asynchronous flush and chain with
		* parent bio. Otherwise directly call nd_region flush.
		*/
		if (bio && bio->bi_iter.bi_sector != -1) {
		struct bio *child = bio_alloc(GFP_ATOMIC, 0);

		if (!child)
		return -ENOMEM;
		bio_copy_dev(child, bio);
		child->bi_opf = REQ_PREFLUSH;
		child->bi_iter.bi_sector = -1;
		bio_chain(child, bio);
		submit_bio(child);
		return 0;
		}
		if (virtio_pmem_flush(nd_region))
		return -EIO;

		return 0;
		};
		EXPORT_SYMBOL_GPL(async_pmem_flush);
		MODULE_LICENSE("GPL");

drivers/nvdimm/virtio_pmem.c

0 → 100644

+122 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* virtio_pmem.c: Virtio pmem Driver
		*
		* Discovers persistent memory range information
		* from host and registers the virtual pmem device
		* with libnvdimm core.
		*/
		#include "virtio_pmem.h"
		#include "nd.h"

		static struct virtio_device_id id_table[] = {
		{ VIRTIO_ID_PMEM, VIRTIO_DEV_ANY_ID },
		{ 0 },
		};

		/* Initialize virt queue */
		static int init_vq(struct virtio_pmem *vpmem)
		{
		/* single vq */
		vpmem->req_vq = virtio_find_single_vq(vpmem->vdev,
		virtio_pmem_host_ack, "flush_queue");
		if (IS_ERR(vpmem->req_vq))
		return PTR_ERR(vpmem->req_vq);

		spin_lock_init(&vpmem->pmem_lock);
		INIT_LIST_HEAD(&vpmem->req_list);

		return 0;
		};

		static int virtio_pmem_probe(struct virtio_device *vdev)
		{
		struct nd_region_desc ndr_desc = {};
		int nid = dev_to_node(&vdev->dev);
		struct nd_region *nd_region;
		struct virtio_pmem *vpmem;
		struct resource res;
		int err = 0;

		if (!vdev->config->get) {
		dev_err(&vdev->dev, "%s failure: config access disabled\n",
		__func__);
		return -EINVAL;
		}

		vpmem = devm_kzalloc(&vdev->dev, sizeof(*vpmem), GFP_KERNEL);
		if (!vpmem) {
		err = -ENOMEM;
		goto out_err;
		}

		vpmem->vdev = vdev;
		vdev->priv = vpmem;
		err = init_vq(vpmem);
		if (err) {
		dev_err(&vdev->dev, "failed to initialize virtio pmem vq's\n");
		goto out_err;
		}

		virtio_cread(vpmem->vdev, struct virtio_pmem_config,
		start, &vpmem->start);
		virtio_cread(vpmem->vdev, struct virtio_pmem_config,
		size, &vpmem->size);

		res.start = vpmem->start;
		res.end = vpmem->start + vpmem->size - 1;
		vpmem->nd_desc.provider_name = "virtio-pmem";
		vpmem->nd_desc.module = THIS_MODULE;

		vpmem->nvdimm_bus = nvdimm_bus_register(&vdev->dev,
		&vpmem->nd_desc);
		if (!vpmem->nvdimm_bus) {
		dev_err(&vdev->dev, "failed to register device with nvdimm_bus\n");
		err = -ENXIO;
		goto out_vq;
		}

		dev_set_drvdata(&vdev->dev, vpmem->nvdimm_bus);

		ndr_desc.res = &res;
		ndr_desc.numa_node = nid;
		ndr_desc.flush = async_pmem_flush;
		set_bit(ND_REGION_PAGEMAP, &ndr_desc.flags);
		set_bit(ND_REGION_ASYNC, &ndr_desc.flags);
		nd_region = nvdimm_pmem_region_create(vpmem->nvdimm_bus, &ndr_desc);
		if (!nd_region) {
		dev_err(&vdev->dev, "failed to create nvdimm region\n");
		err = -ENXIO;
		goto out_nd;
		}
		nd_region->provider_data = dev_to_virtio(nd_region->dev.parent->parent);
		return 0;
		out_nd:
		nvdimm_bus_unregister(vpmem->nvdimm_bus);
		out_vq:
		vdev->config->del_vqs(vdev);
		out_err:
		return err;
		}

		static void virtio_pmem_remove(struct virtio_device *vdev)
		{
		struct nvdimm_bus *nvdimm_bus = dev_get_drvdata(&vdev->dev);

		nvdimm_bus_unregister(nvdimm_bus);
		vdev->config->del_vqs(vdev);
		vdev->config->reset(vdev);
		}

		static struct virtio_driver virtio_pmem_driver = {
		.driver.name = KBUILD_MODNAME,
		.driver.owner = THIS_MODULE,
		.id_table = id_table,
		.probe = virtio_pmem_probe,
		.remove = virtio_pmem_remove,
		};

		module_virtio_driver(virtio_pmem_driver);
		MODULE_DEVICE_TABLE(virtio, id_table);
		MODULE_DESCRIPTION("Virtio pmem driver");
		MODULE_LICENSE("GPL");

drivers/nvdimm/virtio_pmem.h

0 → 100644

+55 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* virtio_pmem.h: virtio pmem Driver
		*
		* Discovers persistent memory range information
		* from host and provides a virtio based flushing
		* interface.
		**/

		#ifndef _LINUX_VIRTIO_PMEM_H
		#define _LINUX_VIRTIO_PMEM_H

		#include <linux/module.h>
		#include <uapi/linux/virtio_pmem.h>
		#include <linux/libnvdimm.h>
		#include <linux/spinlock.h>

		struct virtio_pmem_request {
		struct virtio_pmem_req req;
		struct virtio_pmem_resp resp;

		/* Wait queue to process deferred work after ack from host */
		wait_queue_head_t host_acked;
		bool done;

		/* Wait queue to process deferred work after virt queue buffer avail */
		wait_queue_head_t wq_buf;
		bool wq_buf_avail;
		struct list_head list;
		};

		struct virtio_pmem {
		struct virtio_device *vdev;

		/* Virtio pmem request queue */
		struct virtqueue *req_vq;

		/* nvdimm bus registers virtio pmem device */
		struct nvdimm_bus *nvdimm_bus;
		struct nvdimm_bus_descriptor nd_desc;

		/* List to store deferred work if virtqueue is full */
		struct list_head req_list;

		/* Synchronize virtqueue data */
		spinlock_t pmem_lock;

		/* Memory region information */
		__u64 start;
		__u64 size;
		};

		void virtio_pmem_host_ack(struct virtqueue *vq);
		int async_pmem_flush(struct nd_region nd_region, struct bio bio);
		#endif

drivers/virtio/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,17 @@ config VIRTIO_PCI_LEGACY

		If unsure, say Y.

		config VIRTIO_PMEM
		tristate "Support for virtio pmem driver"
		depends on VIRTIO
		depends on LIBNVDIMM
		help
		This driver provides access to virtio-pmem devices, storage devices
		that are mapped into the physical address space - similar to NVDIMMs
		- with a virtio-based flushing interface.

		If unsure, say Y.

		config VIRTIO_BALLOON
		tristate "Virtio balloon driver"
		depends on VIRTIO

Admin message