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

6 files changed, 25 insertions, 69 deletions

diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 9c3f8160ef24..c613d2e3d371 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -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);
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index 71517b3c5558..7ad57094d736 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -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);
diff --git a/drivers/vhost/test.c b/drivers/vhost/test.c
index 3cc98c07dcd3..906b8f0f19f7 100644
--- a/drivers/vhost/test.c
+++ b/drivers/vhost/test.c
@@ -157,7 +157,7 @@ static int vhost_test_release(struct inode *inode, struct file *f)
 
         vhost_test_stop(n, &private);
         vhost_test_flush(n);
-        vhost_dev_cleanup(&n->dev, false);
+        vhost_dev_cleanup(&n->dev);
         /* We do an extra flush before freeing memory,
          * since jobs can re-queue themselves. */
         vhost_test_flush(n);
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 8d4374606756..2db5af8e8652 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -181,7 +181,6 @@ void vhost_work_init(struct vhost_work *work, vhost_work_fn_t fn)
 {
         clear_bit(VHOST_WORK_QUEUED, &work->flags);
         work->fn = fn;
-        init_waitqueue_head(&work->done);
 }
 EXPORT_SYMBOL_GPL(vhost_work_init);
 
@@ -319,10 +318,8 @@ static void vhost_vq_reset(struct vhost_dev *dev,
         vq->acked_features = 0;
         vq->log_base = NULL;
         vq->error_ctx = NULL;
-        vq->error = NULL;
         vq->kick = NULL;
         vq->call_ctx = NULL;
-        vq->call = NULL;
         vq->log_ctx = NULL;
         vhost_reset_is_le(vq);
         vhost_disable_cross_endian(vq);
@@ -422,7 +419,6 @@ void vhost_dev_init(struct vhost_dev *dev,
         dev->nvqs = nvqs;
         mutex_init(&dev->mutex);
         dev->log_ctx = NULL;
-        dev->log_file = NULL;
         dev->umem = NULL;
         dev->iotlb = NULL;
         dev->mm = NULL;
@@ -544,7 +540,7 @@ void vhost_dev_reset_owner(struct vhost_dev *dev, struct vhost_umem *umem)
 {
         int i;
 
-        vhost_dev_cleanup(dev, true);
+        vhost_dev_cleanup(dev);
 
         /* Restore memory to default empty mapping. */
         INIT_LIST_HEAD(&umem->umem_list);
@@ -611,31 +607,23 @@ static void vhost_clear_msg(struct vhost_dev *dev)
         spin_unlock(&dev->iotlb_lock);
 }
 
-/* Caller should have device mutex if and only if locked is set */
-void vhost_dev_cleanup(struct vhost_dev *dev, bool locked)
+void vhost_dev_cleanup(struct vhost_dev *dev)
 {
         int i;
 
         for (i = 0; i < dev->nvqs; ++i) {
                 if (dev->vqs[i]->error_ctx)
                         eventfd_ctx_put(dev->vqs[i]->error_ctx);
-                if (dev->vqs[i]->error)
-                        fput(dev->vqs[i]->error);
                 if (dev->vqs[i]->kick)
                         fput(dev->vqs[i]->kick);
                 if (dev->vqs[i]->call_ctx)
                         eventfd_ctx_put(dev->vqs[i]->call_ctx);
-                if (dev->vqs[i]->call)
-                        fput(dev->vqs[i]->call);
                 vhost_vq_reset(dev, dev->vqs[i]);
         }
         vhost_dev_free_iovecs(dev);
         if (dev->log_ctx)
                 eventfd_ctx_put(dev->log_ctx);
         dev->log_ctx = NULL;
-        if (dev->log_file)
-                fput(dev->log_file);
-        dev->log_file = NULL;
         /* No one will access memory at this point */
         vhost_umem_clean(dev->umem);
         dev->umem = NULL;
@@ -1492,38 +1480,24 @@ long vhost_vring_ioctl(struct vhost_dev *d, int ioctl, void __user *argp)
                         r = -EFAULT;
                         break;
                 }
-                eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
-                if (IS_ERR(eventfp)) {
-                        r = PTR_ERR(eventfp);
+                ctx = f.fd == -1 ? NULL : eventfd_ctx_fdget(f.fd);
+                if (IS_ERR(ctx)) {
+                        r = PTR_ERR(ctx);
                         break;
                 }
-                if (eventfp != vq->call) {
-                        filep = vq->call;
-                        ctx = vq->call_ctx;
-                        vq->call = eventfp;
-                        vq->call_ctx = eventfp ?
-                                eventfd_ctx_fileget(eventfp) : NULL;
-                } else
-                        filep = eventfp;
+                swap(ctx, vq->call_ctx);
                 break;
         case VHOST_SET_VRING_ERR:
                 if (copy_from_user(&f, argp, sizeof f)) {
                         r = -EFAULT;
                         break;
                 }
-                eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
-                if (IS_ERR(eventfp)) {
-                        r = PTR_ERR(eventfp);
+                ctx = f.fd == -1 ? NULL : eventfd_ctx_fdget(f.fd);
+                if (IS_ERR(ctx)) {
+                        r = PTR_ERR(ctx);
                         break;
                 }
-                if (eventfp != vq->error) {
-                        filep = vq->error;
-                        vq->error = eventfp;
-                        ctx = vq->error_ctx;
-                        vq->error_ctx = eventfp ?
-                                eventfd_ctx_fileget(eventfp) : NULL;
-                } else
-                        filep = eventfp;
+                swap(ctx, vq->error_ctx);
                 break;
         case VHOST_SET_VRING_ENDIAN:
                 r = vhost_set_vring_endian(vq, argp);
@@ -1551,7 +1525,7 @@ long vhost_vring_ioctl(struct vhost_dev *d, int ioctl, void __user *argp)
         if (pollstop && vq->handle_kick)
                 vhost_poll_stop(&vq->poll);
 
-        if (ctx)
+        if (!IS_ERR_OR_NULL(ctx))
                 eventfd_ctx_put(ctx);
         if (filep)
                 fput(filep);
@@ -1594,8 +1568,7 @@ EXPORT_SYMBOL_GPL(vhost_init_device_iotlb);
 /* Caller must have device mutex */
 long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *argp)
 {
-        struct file *eventfp, *filep = NULL;
-        struct eventfd_ctx *ctx = NULL;
+        struct eventfd_ctx *ctx;
         u64 p;
         long r;
         int i, fd;
@@ -1641,19 +1614,12 @@ long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *argp)
                 r = get_user(fd, (int __user *)argp);
                 if (r < 0)
                         break;
-                eventfp = fd == -1 ? NULL : eventfd_fget(fd);
-                if (IS_ERR(eventfp)) {
-                        r = PTR_ERR(eventfp);
+                ctx = fd == -1 ? NULL : eventfd_ctx_fdget(fd);
+                if (IS_ERR(ctx)) {
+                        r = PTR_ERR(ctx);
                         break;
                 }
-                if (eventfp != d->log_file) {
-                        filep = d->log_file;
-                        d->log_file = eventfp;
-                        ctx = d->log_ctx;
-                        d->log_ctx = eventfp ?
-                                eventfd_ctx_fileget(eventfp) : NULL;
-                } else
-                        filep = eventfp;
+                swap(ctx, d->log_ctx);
                 for (i = 0; i < d->nvqs; ++i) {
                         mutex_lock(&d->vqs[i]->mutex);
                         d->vqs[i]->log_ctx = d->log_ctx;
@@ -1661,8 +1627,6 @@ long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *argp)
                 }
                 if (ctx)
                         eventfd_ctx_put(ctx);
-                if (filep)
-                        fput(filep);
                 break;
         default:
                 r = -ENOIOCTLCMD;
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index 7876a3d7d1b3..ac4b6056f19a 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -20,10 +20,6 @@ typedef void (*vhost_work_fn_t)(struct vhost_work *work);
 struct vhost_work {
         struct llist_node         node;
         vhost_work_fn_t           fn;
-        wait_queue_head_t         done;
-        int                       flushing;
-        unsigned                  queue_seq;
-        unsigned                  done_seq;
         unsigned long             flags;
 };
 
@@ -96,8 +92,6 @@ struct vhost_virtqueue {
         struct vring_used __user *used;
         const struct vhost_umem_node *meta_iotlb[VHOST_NUM_ADDRS];
         struct file *kick;
-        struct file *call;
-        struct file *error;
         struct eventfd_ctx *call_ctx;
         struct eventfd_ctx *error_ctx;
         struct eventfd_ctx *log_ctx;
@@ -163,7 +157,6 @@ struct vhost_dev {
         struct mutex mutex;
         struct vhost_virtqueue **vqs;
         int nvqs;
-        struct file *log_file;
         struct eventfd_ctx *log_ctx;
         struct llist_head work_list;
         struct task_struct *worker;
@@ -181,7 +174,7 @@ bool vhost_dev_has_owner(struct vhost_dev *dev);
 long vhost_dev_check_owner(struct vhost_dev *);
 struct vhost_umem *vhost_dev_reset_owner_prepare(void);
 void vhost_dev_reset_owner(struct vhost_dev *, struct vhost_umem *);
-void vhost_dev_cleanup(struct vhost_dev *, bool locked);
+void vhost_dev_cleanup(struct vhost_dev *);
 void vhost_dev_stop(struct vhost_dev *);
 long vhost_dev_ioctl(struct vhost_dev *, unsigned int ioctl, void __user *argp);
 long vhost_vring_ioctl(struct vhost_dev *d, int ioctl, void __user *argp);
diff --git a/drivers/vhost/vsock.c b/drivers/vhost/vsock.c
index 5a5e981bd8e4..0d14e2ff19f1 100644
--- a/drivers/vhost/vsock.c
+++ b/drivers/vhost/vsock.c
@@ -599,7 +599,7 @@ static int vhost_vsock_dev_release(struct inode *inode, struct file *file)
         }
         spin_unlock_bh(&vsock->send_pkt_list_lock);
 
-        vhost_dev_cleanup(&vsock->dev, false);
+        vhost_dev_cleanup(&vsock->dev);
         kfree(vsock->dev.vqs);
         vhost_vsock_free(vsock);
         return 0;