Orangefs: implement .write_iter

Until now, orangefs_devreq_write_iter has just been a wrapper for
the old-fashioned orangefs_devreq_writev... linux would call
.write_iter with "struct kiocb *iocb" and "struct iov_iter *iter"
and .write_iter would just:

        return pvfs2_devreq_writev(iocb->ki_filp,
                                   iter->iov,
                                   iter->nr_segs,
                                   &iocb->ki_pos);
Signed-off-by: NMike Marshall <hubcap@omnibond.com>

fs/orangefs/devorangefs-req.c

@@ -245,202 +245,156 @@ static ssize_t orangefs_devreq_read(struct file *file,
 }
 
 /*
- * Function for writev() callers into the device. Readdir related
- * operations have an extra iovec containing info about objects
- * contained in directories.
+ * Function for writev() callers into the device.
+ *
+ * Userspace should have written:
+ *  - __u32 version
+ *  - __u32 magic
+ *  - __u64 tag
+ *  - struct orangefs_downcall_s
+ *  - trailer buffer (in the case of READDIR operations)
  */
-static ssize_t orangefs_devreq_writev(struct file *file,
-				   const struct iovec *iov,
-				   size_t count,
-				   loff_t *offset)
+static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
+				      struct iov_iter *iter)
 {
+	ssize_t ret;
 	struct orangefs_kernel_op_s *op = NULL;
-	void *buffer = NULL;
-	void *ptr = NULL;
-	unsigned long i = 0;
-	int num_remaining = MAX_DEV_REQ_DOWNSIZE;
-	int ret = 0;
-	/* num elements in iovec without trailer */
-	int notrailer_count = 4;
-	/*
-	 * If there's a trailer, its iov index will be equal to
-	 * notrailer_count.
-	 */
-	int trailer_index = notrailer_count;
-	int payload_size = 0;
-	int returned_downcall_size = 0;
-	__s32 magic = 0;
-	__s32 proto_ver = 0;
-	__u64 tag = 0;
-	ssize_t total_returned_size = 0;
+	struct {
+		__u32 version;
+		__u32 magic;
+		__u64 tag;
+	} head;
+	int total = ret = iov_iter_count(iter);
+	int n;
+	int downcall_size = sizeof(struct orangefs_downcall_s);
+	int head_size = sizeof(head);
+
+	gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n",
+		     __func__,
+		     total,
+		     ret);
 
-	/*
-	 * There will always be at least notrailer_count iovecs, and
-	 * when there's a trailer, one more than notrailer_count. Check
-	 * count's sanity.
-	 */
-	if (count != notrailer_count && count != (notrailer_count + 1)) {
-		gossip_err("%s: count:%zu: notrailer_count :%d:\n",
+        if (total < MAX_DEV_REQ_DOWNSIZE) {
+		gossip_err("%s: total:%d: must be at least:%lu:\n",
 			   __func__,
-			count,
-			notrailer_count);
-		return -EPROTO;
+			   total,
+			   MAX_DEV_REQ_DOWNSIZE);
+		ret = -EFAULT;
+		goto out;
 	}
      
-
-	/* Copy the non-trailer iovec data into a device request buffer. */
-	buffer = dev_req_alloc();
-	if (!buffer) {
-		gossip_err("%s: dev_req_alloc failed.\n", __func__);
-		return -ENOMEM;
-	}
-	ptr = buffer;
-	for (i = 0; i < notrailer_count; i++) {
-		if (iov[i].iov_len > num_remaining) {
-			gossip_err
-			    ("writev error: Freeing buffer and returning\n");
-			dev_req_release(buffer);
-			return -EMSGSIZE;
-		}
-		ret = copy_from_user(ptr, iov[i].iov_base, iov[i].iov_len);
-		if (ret) {
-			gossip_err("Failed to copy data from user space\n");
-			dev_req_release(buffer);
-			return -EIO;
-		}
-		num_remaining -= iov[i].iov_len;
-		ptr += iov[i].iov_len;
-		payload_size += iov[i].iov_len;
+	n = copy_from_iter(&head, head_size, iter);
+	if (n < head_size) {
+		gossip_err("%s: failed to copy head.\n", __func__);
+		ret = -EFAULT;
+		goto out;
 	}
-	total_returned_size = payload_size;
-
-	/* these elements are currently 8 byte aligned (8 bytes for (version +
-	 * magic) 8 bytes for tag).  If you add another element, either
-	 * make it 8 bytes big, or use get_unaligned when asigning.
-	 */
-	ptr = buffer;
-	proto_ver = *((__s32 *) ptr); /* unused */
-	ptr += sizeof(__s32);
 
-	magic = *((__s32 *) ptr);
-	ptr += sizeof(__s32);
-
-	tag = *((__u64 *) ptr);
-	ptr += sizeof(__u64);
+	if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) {
+		gossip_err("%s: userspace claims version"
+			   "%d, minimum version required: %d.\n",
+			   __func__,
+			   head.version,
+			   ORANGEFS_MINIMUM_USERSPACE_VERSION);
+		ret = -EPROTO;
+		goto out;
+	}
 
-	if (magic != ORANGEFS_DEVREQ_MAGIC) {
+	if (head.magic != ORANGEFS_DEVREQ_MAGIC) {
 		gossip_err("Error: Device magic number does not match.\n");
-		dev_req_release(buffer);
-		return -EPROTO;
+		ret = -EPROTO;
+		goto out;
 	}
 
-	op = orangefs_devreq_remove_op(tag);
-	if (op) {
-		/* Increase ref count! */
-		get_op(op);
-
-		/* calculate the size of the returned downcall. */
-		returned_downcall_size =
-			payload_size - (2 * sizeof(__s32) + sizeof(__u64));
-
-		/* copy the passed in downcall into the op */
-		if (returned_downcall_size ==
-			sizeof(struct orangefs_downcall_s)) {
-			memcpy(&op->downcall,
-			       ptr,
-			       sizeof(struct orangefs_downcall_s));
-		} else {
-			gossip_err("%s: returned downcall size:%d: \n",
-				   __func__,
-				   returned_downcall_size);
-			dev_req_release(buffer);
-			put_op(op);
-			return -EMSGSIZE;
+	op = orangefs_devreq_remove_op(head.tag);
+	if (!op) {
+		gossip_err("WARNING: No one's waiting for tag %llu\n",
+			   llu(head.tag));
+		goto out;
 	}
 
-		/* Don't tolerate an unexpected trailer iovec. */
-		if ((op->downcall.trailer_size == 0) &&
-		    (count != notrailer_count)) {
-			gossip_err("%s: unexpected trailer iovec.\n",
-				   __func__);
-			dev_req_release(buffer);
+	get_op(op); /* increase ref count. */
+
+	n = copy_from_iter(&op->downcall, downcall_size, iter);
+	if (n != downcall_size) {
+		gossip_err("%s: failed to copy downcall.\n", __func__);
 		put_op(op);
-			return -EPROTO;
+		ret = -EFAULT;
+		goto out;
 	}
 
-		/* Don't consider the trailer if there's a bad status. */
-		if (op->downcall.status != 0)
-			goto no_trailer;
-
-		/* get the trailer if there is one. */
-		if (op->downcall.trailer_size == 0)
-			goto no_trailer;
-
-		gossip_debug(GOSSIP_DEV_DEBUG,
-			     "%s: op->downcall.trailer_size %lld\n",
-			     __func__,
-			     op->downcall.trailer_size);
+	if (op->downcall.status)
+		goto wakeup;
 
 	/*
-		 * Bail if we think think there should be a trailer, but
-		 * there's no iovec for it.
+	 * We've successfully peeled off the head and the downcall. 
+	 * Something has gone awry if total doesn't equal the
+	 * sum of head_size, downcall_size and trailer_size.
 	 */
-		if (count != (notrailer_count + 1)) {
-			gossip_err("%s: trailer_size:%lld: count:%zu:\n",
+	if ((head_size + downcall_size + op->downcall.trailer_size) != total) {
+		gossip_err("%s: funky write, head_size:%d"
+			   ": downcall_size:%d: trailer_size:%lld"
+			   ": total size:%d:\n",
 			   __func__,
+			   head_size,
+			   downcall_size,
 			   op->downcall.trailer_size,
-				   count);
-			dev_req_release(buffer);
+			   total);
 		put_op(op);
-			return -EPROTO;
+		ret = -EFAULT;
+		goto out;
 	}
 
-		/* Verify that trailer_size is accurate. */
-		if (op->downcall.trailer_size != iov[trailer_index].iov_len) {
-			gossip_err("%s: trailer_size:%lld: != iov_len:%zd:\n",
+	/* Only READDIR operations should have trailers. */
+	if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) &&
+	    (op->downcall.trailer_size != 0)) {
+		gossip_err("%s: %x operation with trailer.",
 			   __func__,
-				   op->downcall.trailer_size,
-				   iov[trailer_index].iov_len);
-			dev_req_release(buffer);
+			   op->downcall.type);
 		put_op(op);
-			return -EMSGSIZE;
+		ret = -EFAULT;
+		goto out;
 	}
 
-		total_returned_size += iov[trailer_index].iov_len;
+	/* READDIR operations should always have trailers. */
+	if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) &&
+	    (op->downcall.trailer_size == 0)) {
+		gossip_err("%s: %x operation with no trailer.",
+			   __func__,
+			   op->downcall.type);
+		put_op(op);
+		ret = -EFAULT;
+		goto out;
+	}
 
-		/*
-		 * Allocate a buffer, copy the trailer bytes into it and
-		 * attach it to the downcall.
-		 */
-		op->downcall.trailer_buf = vmalloc(iov[trailer_index].iov_len);
-		if (op->downcall.trailer_buf != NULL) {
-			gossip_debug(GOSSIP_DEV_DEBUG, "vmalloc: %p\n",
-				     op->downcall.trailer_buf);
-			ret = copy_from_user(op->downcall.trailer_buf,
-					     iov[trailer_index].iov_base,
-					     iov[trailer_index].iov_len);
-			if (ret) {
-				gossip_err("%s: Failed to copy trailer.\n",
+	if (op->downcall.type != ORANGEFS_VFS_OP_READDIR)
+		goto wakeup;
+
+	op->downcall.trailer_buf =
+		vmalloc(op->downcall.trailer_size);
+	if (op->downcall.trailer_buf == NULL) {
+		gossip_err("%s: failed trailer vmalloc.\n",
 			   __func__);
-				dev_req_release(buffer);
-				gossip_debug(GOSSIP_DEV_DEBUG,
-					     "vfree: %p\n",
-					     op->downcall.trailer_buf);
-				vfree(op->downcall.trailer_buf);
-				op->downcall.trailer_buf = NULL;
 		put_op(op);
-				return -EIO;
+		ret = -ENOMEM;
+		goto out;
 	}
-		} else {
-			gossip_err("writev: could not vmalloc for trailer!\n");
-			dev_req_release(buffer);
+	memset(op->downcall.trailer_buf, 0, op->downcall.trailer_size);
+	n = copy_from_iter(op->downcall.trailer_buf,
+			   op->downcall.trailer_size,
+			   iter);
+	if (n != op->downcall.trailer_size) {
+		gossip_err("%s: failed to copy trailer.\n", __func__);
+		vfree(op->downcall.trailer_buf);
 		put_op(op);
-			return -ENOMEM;
+		ret = -EFAULT;
+		goto out;
 	}
 
-no_trailer:
+wakeup:
 
-		/* if this operation is an I/O operation we need to wait
+	/*
+	 * If this operation is an I/O operation we need to wait
 	 * for all data to be copied before we can return to avoid
 	 * buffer corruption and races that can pull the buffers
 	 * out from under us.
@@ -450,7 +404,7 @@ static ssize_t orangefs_devreq_writev(struct file *file,
 	 * application reading/writing this device to return until
 	 * the buffers are done being used.
 	 */
-		if (op->upcall.type == ORANGEFS_VFS_OP_FILE_IO) {
+	if (op->downcall.type == ORANGEFS_VFS_OP_FILE_IO) {
 		int timed_out = 0;
 		DEFINE_WAIT(wait_entry);
 
@@ -509,7 +463,6 @@ static ssize_t orangefs_devreq_writev(struct file *file,
 		if (!timed_out)
 			op_release(op);
 	} else {
-
 		/*
 		 * tell the vfs op waiting on a waitqueue that
 		 * this op is done
@@ -524,25 +477,8 @@ static ssize_t orangefs_devreq_writev(struct file *file,
 		 */
 		wake_up_interruptible(&op->waitq);
 	}
-	} else {
-		/* ignore downcalls that we're not interested in */
-		gossip_debug(GOSSIP_DEV_DEBUG,
-			     "WARNING: No one's waiting for tag %llu\n",
-			     llu(tag));
-	}
-	/* put_op? */
-	dev_req_release(buffer);
-
-	return total_returned_size;
-}
-
-static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
-				      struct iov_iter *iter)
-{
-	return orangefs_devreq_writev(iocb->ki_filp,
-				   iter->iov,
-				   iter->nr_segs,
-				   &iocb->ki_pos);
+out:
+	return ret;
 }
 
 /* Returns whether any FS are still pending remounted */