iov_iter: Separate type from direction and use accessor functions

In the iov_iter struct, separate the iterator type from the iterator
direction and use accessor functions to access them in most places.

Convert a bunch of places to use switch-statements to access them rather
then chains of bitwise-AND statements.  This makes it easier to add further
iterator types.  Also, this can be more efficient as to implement a switch
of small contiguous integers, the compiler can use ~50% fewer compare
instructions than it has to use bitwise-and instructions.

Further, cease passing the iterator type into the iterator setup function.
The iterator function can set that itself.  Only the direction is required.

Signed-off-by: David Howells <dhowells@redhat.com>

diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index ef8212a4b73ef5cf2a659ac62170d6efaec291f0..ded9735d44af25f5e314cddcd537ca3c0de46b66 100644 (file)
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -1856,7 +1856,7 @@ int drbd_send(struct drbd_connection *connection, struct socket *sock,
 
        /* THINK  if (signal_pending) return ... ? */
 
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, &iov, 1, size);
+       iov_iter_kvec(&msg.msg_iter, WRITE, &iov, 1, size);
 
        if (sock == connection->data.socket) {
                rcu_read_lock();

diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 75f6b47169e65ac8141ec507a974fb3622d1b562..fcc70642b00497db024c9c74d0bf2ba6b724ae03 100644 (file)
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -516,7 +516,7 @@ static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flag
        struct msghdr msg = {
                .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL)
        };
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, size);
+       iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, size);
        return sock_recvmsg(sock, &msg, msg.msg_flags);
 }
 

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index ea9debf59b225c19d815e7ff1fd8aa950f5dcb1b..cb0cc868507620513d3de7658ed1f6999ceaa965 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -268,7 +268,7 @@ static int lo_write_bvec(struct file *file, struct bio_vec *bvec, loff_t *ppos)
        struct iov_iter i;
        ssize_t bw;
 
-       iov_iter_bvec(&i, ITER_BVEC | WRITE, bvec, 1, bvec->bv_len);
+       iov_iter_bvec(&i, WRITE, bvec, 1, bvec->bv_len);
 
        file_start_write(file);
        bw = vfs_iter_write(file, &i, ppos, 0);
@@ -346,7 +346,7 @@ static int lo_read_simple(struct loop_device *lo, struct request *rq,
        ssize_t len;
 
        rq_for_each_segment(bvec, rq, iter) {
-               iov_iter_bvec(&i, ITER_BVEC, &bvec, 1, bvec.bv_len);
+               iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len);
                len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);
                if (len < 0)
                        return len;
@@ -387,7 +387,7 @@ static int lo_read_transfer(struct loop_device *lo, struct request *rq,
                b.bv_offset = 0;
                b.bv_len = bvec.bv_len;
 
-               iov_iter_bvec(&i, ITER_BVEC, &b, 1, b.bv_len);
+               iov_iter_bvec(&i, READ, &b, 1, b.bv_len);
                len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);
                if (len < 0) {
                        ret = len;
@@ -554,8 +554,7 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
        }
        atomic_set(&cmd->ref, 2);
 
-       iov_iter_bvec(&iter, ITER_BVEC | rw, bvec,
-                     segments, blk_rq_bytes(rq));
+       iov_iter_bvec(&iter, rw, bvec, segments, blk_rq_bytes(rq));
        iter.iov_offset = offset;
 
        cmd->iocb.ki_pos = pos;

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 14a51254c3db7f19c94cdab62e1d9e192c7ae02f..4d4d6129ff6627f1249cade3101d2927d7db5a25 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -473,7 +473,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index)
        u32 nbd_cmd_flags = 0;
        int sent = nsock->sent, skip = 0;
 
-       iov_iter_kvec(&from, WRITE | ITER_KVEC, &iov, 1, sizeof(request));
+       iov_iter_kvec(&from, WRITE, &iov, 1, sizeof(request));
 
        switch (req_op(req)) {
        case REQ_OP_DISCARD:
@@ -564,8 +564,7 @@ send_pages:
 
                        dev_dbg(nbd_to_dev(nbd), "request %p: sending %d bytes data\n",
                                req, bvec.bv_len);
-                       iov_iter_bvec(&from, ITER_BVEC | WRITE,
-                                     &bvec, 1, bvec.bv_len);
+                       iov_iter_bvec(&from, WRITE, &bvec, 1, bvec.bv_len);
                        if (skip) {
                                if (skip >= iov_iter_count(&from)) {
                                        skip -= iov_iter_count(&from);
@@ -624,7 +623,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index)
        int ret = 0;
 
        reply.magic = 0;
-       iov_iter_kvec(&to, READ | ITER_KVEC, &iov, 1, sizeof(reply));
+       iov_iter_kvec(&to, READ, &iov, 1, sizeof(reply));
        result = sock_xmit(nbd, index, 0, &to, MSG_WAITALL, NULL);
        if (result <= 0) {
                if (!nbd_disconnected(config))
@@ -678,8 +677,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index)
                struct bio_vec bvec;
 
                rq_for_each_segment(bvec, req, iter) {
-                       iov_iter_bvec(&to, ITER_BVEC | READ,
-                                     &bvec, 1, bvec.bv_len);
+                       iov_iter_bvec(&to, READ, &bvec, 1, bvec.bv_len);
                        result = sock_xmit(nbd, index, 0, &to, MSG_WAITALL, NULL);
                        if (result <= 0) {
                                dev_err(disk_to_dev(nbd->disk), "Receive data failed (result %d)\n",
@@ -1073,7 +1071,7 @@ static void send_disconnects(struct nbd_device *nbd)
        for (i = 0; i < config->num_connections; i++) {
                struct nbd_sock *nsock = config->socks[i];
 
-               iov_iter_kvec(&from, WRITE | ITER_KVEC, &iov, 1, sizeof(request));
+               iov_iter_kvec(&from, WRITE, &iov, 1, sizeof(request));
                mutex_lock(&nsock->tx_lock);
                ret = sock_xmit(nbd, i, 1, &from, 0, NULL);
                if (ret <= 0)

diff --git a/drivers/fsi/fsi-sbefifo.c b/drivers/fsi/fsi-sbefifo.c
index ae861342626e3516527167b18d96a7f5ac522169..d92f5b87c251e1248e20fd44708a4d80f759bc00 100644 (file)
--- a/drivers/fsi/fsi-sbefifo.c
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -638,7 +638,7 @@ static void sbefifo_collect_async_ffdc(struct sbefifo *sbefifo)
        }
         ffdc_iov.iov_base = ffdc;
        ffdc_iov.iov_len = SBEFIFO_MAX_FFDC_SIZE;
-        iov_iter_kvec(&ffdc_iter, WRITE | ITER_KVEC, &ffdc_iov, 1, SBEFIFO_MAX_FFDC_SIZE);
+        iov_iter_kvec(&ffdc_iter, WRITE, &ffdc_iov, 1, SBEFIFO_MAX_FFDC_SIZE);
        cmd[0] = cpu_to_be32(2);
        cmd[1] = cpu_to_be32(SBEFIFO_CMD_GET_SBE_FFDC);
        rc = sbefifo_do_command(sbefifo, cmd, 2, &ffdc_iter);
@@ -735,7 +735,7 @@ int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
        rbytes = (*resp_len) * sizeof(__be32);
        resp_iov.iov_base = response;
        resp_iov.iov_len = rbytes;
-        iov_iter_kvec(&resp_iter, WRITE | ITER_KVEC, &resp_iov, 1, rbytes);
+        iov_iter_kvec(&resp_iter, WRITE, &resp_iov, 1, rbytes);
 
        /* Perform the command */
        mutex_lock(&sbefifo->lock);

diff --git a/drivers/isdn/mISDN/l1oip_core.c b/drivers/isdn/mISDN/l1oip_core.c
index b05022f94f18c22ff2c72fa71cf11984077152b7..072bb5e36c184e6945624ec07dc27595fe8e7a7d 100644 (file)
--- a/drivers/isdn/mISDN/l1oip_core.c
+++ b/drivers/isdn/mISDN/l1oip_core.c
@@ -718,8 +718,7 @@ l1oip_socket_thread(void *data)
                printk(KERN_DEBUG "%s: socket created and open\n",
                       __func__);
        while (!signal_pending(current)) {
-               iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1,
-                               recvbuf_size);
+               iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, recvbuf_size);
                recvlen = sock_recvmsg(socket, &msg, 0);
                if (recvlen > 0) {
                        l1oip_socket_parse(hc, &sin_rx, recvbuf, recvlen);

diff --git a/drivers/misc/vmw_vmci/vmci_queue_pair.c b/drivers/misc/vmw_vmci/vmci_queue_pair.c
index bd52f29b4a4e273eb6f69a56c34a0789279d2226..264f4ed8eef26e8f839d121d905497c3c75de67c 100644 (file)
--- a/drivers/misc/vmw_vmci/vmci_queue_pair.c
+++ b/drivers/misc/vmw_vmci/vmci_queue_pair.c
@@ -3030,7 +3030,7 @@ ssize_t vmci_qpair_enqueue(struct vmci_qp *qpair,
        if (!qpair || !buf)
                return VMCI_ERROR_INVALID_ARGS;
 
-       iov_iter_kvec(&from, WRITE | ITER_KVEC, &v, 1, buf_size);
+       iov_iter_kvec(&from, WRITE, &v, 1, buf_size);
 
        qp_lock(qpair);
 
@@ -3074,7 +3074,7 @@ ssize_t vmci_qpair_dequeue(struct vmci_qp *qpair,
        if (!qpair || !buf)
                return VMCI_ERROR_INVALID_ARGS;
 
-       iov_iter_kvec(&to, READ | ITER_KVEC, &v, 1, buf_size);
+       iov_iter_kvec(&to, READ, &v, 1, buf_size);
 
        qp_lock(qpair);
 
@@ -3119,7 +3119,7 @@ ssize_t vmci_qpair_peek(struct vmci_qp *qpair,
        if (!qpair || !buf)
                return VMCI_ERROR_INVALID_ARGS;
 
-       iov_iter_kvec(&to, READ | ITER_KVEC, &v, 1, buf_size);
+       iov_iter_kvec(&to, READ, &v, 1, buf_size);
 
        qp_lock(qpair);
 

diff --git a/drivers/nvme/target/io-cmd-file.c b/drivers/nvme/target/io-cmd-file.c
index 81a9dc5290a8744b3f022aec8338098986b23967..97f282eca3c2834081ad2bd0a4d207aeaee529ad 100644 (file)
--- a/drivers/nvme/target/io-cmd-file.c
+++ b/drivers/nvme/target/io-cmd-file.c
@@ -101,7 +101,7 @@ static ssize_t nvmet_file_submit_bvec(struct nvmet_req *req, loff_t pos,
                rw = READ;
        }
 
-       iov_iter_bvec(&iter, ITER_BVEC | rw, req->f.bvec, nr_segs, count);
+       iov_iter_bvec(&iter, rw, req->f.bvec, nr_segs, count);
 
        iocb->ki_pos = pos;
        iocb->ki_filp = req->ns->file;

diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 49be1e41290cd7c818c8fbfdf918c18f0b29b2bd..991482576417b88aba3dcec07fca41f9618de531 100644 (file)
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -1258,8 +1258,7 @@ static int iscsit_do_rx_data(
                return -1;
 
        memset(&msg, 0, sizeof(struct msghdr));
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC,
-                     count->iov, count->iov_count, data);
+       iov_iter_kvec(&msg.msg_iter, READ, count->iov, count->iov_count, data);
 
        while (msg_data_left(&msg)) {
                rx_loop = sock_recvmsg(conn->sock, &msg, MSG_WAITALL);
@@ -1315,8 +1314,7 @@ int tx_data(
 
        memset(&msg, 0, sizeof(struct msghdr));
 
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC,
-                     iov, iov_count, data);
+       iov_iter_kvec(&msg.msg_iter, WRITE, iov, iov_count, data);
 
        while (msg_data_left(&msg)) {
                int tx_loop = sock_sendmsg(conn->sock, &msg);

diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 16751ae55d7b6f64b2bc9551f588f8b0e5d06cb8..49b110d1b972b671b17f0e1e1dab588628155bc8 100644 (file)
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -303,7 +303,7 @@ fd_execute_rw_aio(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                len += sg->length;
        }
 
-       iov_iter_bvec(&iter, ITER_BVEC | is_write, bvec, sgl_nents, len);
+       iov_iter_bvec(&iter, is_write, bvec, sgl_nents, len);
 
        aio_cmd->cmd = cmd;
        aio_cmd->len = len;
@@ -353,7 +353,7 @@ static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
                len += sg->length;
        }
 
-       iov_iter_bvec(&iter, ITER_BVEC, bvec, sgl_nents, len);
+       iov_iter_bvec(&iter, READ, bvec, sgl_nents, len);
        if (is_write)
                ret = vfs_iter_write(fd, &iter, &pos, 0);
        else
@@ -490,7 +490,7 @@ fd_execute_write_same(struct se_cmd *cmd)
                len += se_dev->dev_attrib.block_size;
        }
 
-       iov_iter_bvec(&iter, ITER_BVEC, bvec, nolb, len);
+       iov_iter_bvec(&iter, READ, bvec, nolb, len);
        ret = vfs_iter_write(fd_dev->fd_file, &iter, &pos, 0);
 
        kfree(bvec);

diff --git a/drivers/usb/usbip/usbip_common.c b/drivers/usb/usbip/usbip_common.c
index 9756752c0681f99c2acb1aaf1213ea23e03055f9..45da3e01c7b03ae04b3c889e73d140baa2c9dc7f 100644 (file)
--- a/drivers/usb/usbip/usbip_common.c
+++ b/drivers/usb/usbip/usbip_common.c
@@ -309,7 +309,7 @@ int usbip_recv(struct socket *sock, void *buf, int size)
        if (!sock || !buf || !size)
                return -EINVAL;
 
-       iov_iter_kvec(&msg.msg_iter, READ|ITER_KVEC, &iov, 1, size);
+       iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, size);
 
        usbip_dbg_xmit("enter\n");
 

diff --git a/drivers/xen/pvcalls-back.c b/drivers/xen/pvcalls-back.c
index b1092fbefa6309d2535b17b78979b6f3fa9b2b42..2e5d845b5091478252dfb1ed17395cf9c5ce870a 100644 (file)
--- a/drivers/xen/pvcalls-back.c
+++ b/drivers/xen/pvcalls-back.c
@@ -137,13 +137,13 @@ static void pvcalls_conn_back_read(void *opaque)
        if (masked_prod < masked_cons) {
                vec[0].iov_base = data->in + masked_prod;
                vec[0].iov_len = wanted;
-               iov_iter_kvec(&msg.msg_iter, ITER_KVEC|WRITE, vec, 1, wanted);
+               iov_iter_kvec(&msg.msg_iter, WRITE, vec, 1, wanted);
        } else {
                vec[0].iov_base = data->in + masked_prod;
                vec[0].iov_len = array_size - masked_prod;
                vec[1].iov_base = data->in;
                vec[1].iov_len = wanted - vec[0].iov_len;
-               iov_iter_kvec(&msg.msg_iter, ITER_KVEC|WRITE, vec, 2, wanted);
+               iov_iter_kvec(&msg.msg_iter, WRITE, vec, 2, wanted);
        }
 
        atomic_set(&map->read, 0);
@@ -195,13 +195,13 @@ static void pvcalls_conn_back_write(struct sock_mapping *map)
        if (pvcalls_mask(prod, array_size) > pvcalls_mask(cons, array_size)) {
                vec[0].iov_base = data->out + pvcalls_mask(cons, array_size);
                vec[0].iov_len = size;
-               iov_iter_kvec(&msg.msg_iter, ITER_KVEC|READ, vec, 1, size);
+               iov_iter_kvec(&msg.msg_iter, READ, vec, 1, size);
        } else {
                vec[0].iov_base = data->out + pvcalls_mask(cons, array_size);
                vec[0].iov_len = array_size - pvcalls_mask(cons, array_size);
                vec[1].iov_base = data->out;
                vec[1].iov_len = size - vec[0].iov_len;
-               iov_iter_kvec(&msg.msg_iter, ITER_KVEC|READ, vec, 2, size);
+               iov_iter_kvec(&msg.msg_iter, READ, vec, 2, size);
        }
 
        atomic_set(&map->write, 0);

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index e1cbdfdb7c684fd24fdb6f25ee03f4e253e9ef58..0bcbcc20f76954e4e8e3d959628e87f3915b3ce3 100644 (file)
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -65,7 +65,7 @@ static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page)
        if (retval == 0)
                return retval;
 
-       iov_iter_bvec(&to, ITER_BVEC | READ, &bvec, 1, PAGE_SIZE);
+       iov_iter_bvec(&to, READ, &bvec, 1, PAGE_SIZE);
 
        retval = p9_client_read(fid, page_offset(page), &to, &err);
        if (err) {
@@ -175,7 +175,7 @@ static int v9fs_vfs_writepage_locked(struct page *page)
        bvec.bv_page = page;
        bvec.bv_offset = 0;
        bvec.bv_len = len;
-       iov_iter_bvec(&from, ITER_BVEC | WRITE, &bvec, 1, len);
+       iov_iter_bvec(&from, WRITE, &bvec, 1, len);
 
        /* We should have writeback_fid always set */
        BUG_ON(!v9inode->writeback_fid);

diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index b0405d6aac854d4e3bb69b813f587775cbeeebe8..d5db3c968a0351caf31b397da09492e536dc854b 100644 (file)
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -133,7 +133,7 @@ static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
                if (rdir->tail == rdir->head) {
                        struct iov_iter to;
                        int n;
-                       iov_iter_kvec(&to, READ | ITER_KVEC, &kvec, 1, buflen);
+                       iov_iter_kvec(&to, READ, &kvec, 1, buflen);
                        n = p9_client_read(file->private_data, ctx->pos, &to,
                                           &err);
                        if (err)

diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index 352abc39e891a1468d3576cc199fa13b089f32f7..ac8ff8ca4c115fa0ae52ec4c8fcbe47499780d94 100644 (file)
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -32,7 +32,7 @@ ssize_t v9fs_fid_xattr_get(struct p9_fid *fid, const char *name,
        struct iov_iter to;
        int err;
 
-       iov_iter_kvec(&to, READ | ITER_KVEC, &kvec, 1, buffer_size);
+       iov_iter_kvec(&to, READ, &kvec, 1, buffer_size);
 
        attr_fid = p9_client_xattrwalk(fid, name, &attr_size);
        if (IS_ERR(attr_fid)) {
@@ -107,7 +107,7 @@ int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
        struct iov_iter from;
        int retval, err;
 
-       iov_iter_kvec(&from, WRITE | ITER_KVEC, &kvec, 1, value_len);
+       iov_iter_kvec(&from, WRITE, &kvec, 1, value_len);
 
        p9_debug(P9_DEBUG_VFS, "name = %s value_len = %zu flags = %d\n",
                 name, value_len, flags);

diff --git a/fs/afs/rxrpc.c b/fs/afs/rxrpc.c
index 77a83790a31f38c9e25ffeaa1c190eb8958e7fa9..639c16882e93259f0724af24c3dcac157ecb8156 100644 (file)
--- a/fs/afs/rxrpc.c
+++ b/fs/afs/rxrpc.c
@@ -286,7 +286,7 @@ static void afs_load_bvec(struct afs_call *call, struct msghdr *msg,
                offset = 0;
        }
 
-       iov_iter_bvec(&msg->msg_iter, WRITE | ITER_BVEC, bv, nr, bytes);
+       iov_iter_bvec(&msg->msg_iter, WRITE, bv, nr, bytes);
 }
 
 /*
@@ -401,8 +401,7 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call,
 
        msg.msg_name            = NULL;
        msg.msg_namelen         = 0;
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1,
-                     call->request_size);
+       iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, call->request_size);
        msg.msg_control         = NULL;
        msg.msg_controllen      = 0;
        msg.msg_flags           = MSG_WAITALL | (call->send_pages ? MSG_MORE : 0);
@@ -432,7 +431,7 @@ error_do_abort:
                rxrpc_kernel_abort_call(call->net->socket, rxcall,
                                        RX_USER_ABORT, ret, "KSD");
        } else {
-               iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, NULL, 0, 0);
+               iov_iter_kvec(&msg.msg_iter, READ, NULL, 0, 0);
                rxrpc_kernel_recv_data(call->net->socket, rxcall,
                                       &msg.msg_iter, false,
                                       &call->abort_code, &call->service_id);
@@ -468,7 +467,7 @@ static void afs_deliver_to_call(struct afs_call *call)
                if (state == AFS_CALL_SV_AWAIT_ACK) {
                        struct iov_iter iter;
 
-                       iov_iter_kvec(&iter, READ | ITER_KVEC, NULL, 0, 0);
+                       iov_iter_kvec(&iter, READ, NULL, 0, 0);
                        ret = rxrpc_kernel_recv_data(call->net->socket,
                                                     call->rxcall, &iter, false,
                                                     &remote_abort,
@@ -825,7 +824,7 @@ void afs_send_empty_reply(struct afs_call *call)
 
        msg.msg_name            = NULL;
        msg.msg_namelen         = 0;
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, NULL, 0, 0);
+       iov_iter_kvec(&msg.msg_iter, WRITE, NULL, 0, 0);
        msg.msg_control         = NULL;
        msg.msg_controllen      = 0;
        msg.msg_flags           = 0;
@@ -864,7 +863,7 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len)
        iov[0].iov_len          = len;
        msg.msg_name            = NULL;
        msg.msg_namelen         = 0;
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1, len);
+       iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, len);
        msg.msg_control         = NULL;
        msg.msg_controllen      = 0;
        msg.msg_flags           = 0;
@@ -905,7 +904,7 @@ int afs_extract_data(struct afs_call *call, void *buf, size_t count,
 
        iov.iov_base = buf + call->offset;
        iov.iov_len = count - call->offset;
-       iov_iter_kvec(&iter, ITER_KVEC | READ, &iov, 1, count - call->offset);
+       iov_iter_kvec(&iter, READ, &iov, 1, count - call->offset);
 
        ret = rxrpc_kernel_recv_data(net->socket, call->rxcall, &iter,
                                     want_more, &remote_abort,

diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 524ecc95b04dee00279a59da29ac370a17812d33..5dd433aa9b234deeed504d32ff5927f624baba69 100644 (file)
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -821,7 +821,7 @@ static void ceph_aio_complete_req(struct ceph_osd_request *req)
                                aio_req->total_len = rc + zlen;
                        }
 
-                       iov_iter_bvec(&i, ITER_BVEC, osd_data->bvec_pos.bvecs,
+                       iov_iter_bvec(&i, READ, osd_data->bvec_pos.bvecs,
                                      osd_data->num_bvecs,
                                      osd_data->bvec_pos.iter.bi_size);
                        iov_iter_advance(&i, rc);
@@ -1044,8 +1044,7 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,
                                int zlen = min_t(size_t, len - ret,
                                                 size - pos - ret);
 
-                               iov_iter_bvec(&i, ITER_BVEC, bvecs, num_pages,
-                                             len);
+                               iov_iter_bvec(&i, READ, bvecs, num_pages, len);
                                iov_iter_advance(&i, ret);
                                iov_iter_zero(zlen, &i);
                                ret += zlen;

diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 52d71b64c0c6e5f954d408098fc78197898399c7..11bcd2fb90b13ef07b98fdcefeecc0973859d5fe 100644 (file)
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -588,7 +588,7 @@ cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 {
        struct msghdr smb_msg;
        struct kvec iov = {.iov_base = buf, .iov_len = to_read};
-       iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
+       iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
 
        return cifs_readv_from_socket(server, &smb_msg);
 }
@@ -600,7 +600,7 @@ cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
        struct msghdr smb_msg;
        struct bio_vec bv = {
                .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
-       iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
+       iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
        return cifs_readv_from_socket(server, &smb_msg);
 }
 

diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 7b5b960a04b8cea3604d5741bebc96d0503c2270..10cff44832d8b86f5dd4b78d80fdf006d1ca69f0 100644 (file)
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -857,7 +857,7 @@ setup_aio_ctx_iter(struct cifs_aio_ctx *ctx, struct iov_iter *iter, int rw)
        ctx->bv = bv;
        ctx->len = saved_len - count;
        ctx->npages = npages;
-       iov_iter_bvec(&ctx->iter, ITER_BVEC | rw, ctx->bv, npages, ctx->len);
+       iov_iter_bvec(&ctx->iter, rw, ctx->bv, npages, ctx->len);
        return 0;
 }
 

diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
index 89985a0a6819e3a2a3348a0c4870157f7220665e..26f8a65b8722fd75c5105f805cb7bd774d725a7a 100644 (file)
--- a/fs/cifs/smb2ops.c
+++ b/fs/cifs/smb2ops.c
@@ -2962,13 +2962,13 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,
                        return 0;
                }
 
-               iov_iter_bvec(&iter, WRITE | ITER_BVEC, bvec, npages, data_len);
+               iov_iter_bvec(&iter, WRITE, bvec, npages, data_len);
        } else if (buf_len >= data_offset + data_len) {
                /* read response payload is in buf */
                WARN_ONCE(npages > 0, "read data can be either in buf or in pages");
                iov.iov_base = buf + data_offset;
                iov.iov_len = data_len;
-               iov_iter_kvec(&iter, WRITE | ITER_KVEC, &iov, 1, data_len);
+               iov_iter_kvec(&iter, WRITE, &iov, 1, data_len);
        } else {
                /* read response payload cannot be in both buf and pages */
                WARN_ONCE(1, "buf can not contain only a part of read data");

diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index b48f43963da6afcc7ff7da565477b00e67d92877..146b618802a5c164df6d88959789a42fd27ce1bd 100644 (file)
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -307,8 +307,7 @@ __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
                        .iov_base = &rfc1002_marker,
                        .iov_len  = 4
                };
-               iov_iter_kvec(&smb_msg.msg_iter, WRITE | ITER_KVEC, &hiov,
-                             1, 4);
+               iov_iter_kvec(&smb_msg.msg_iter, WRITE, &hiov, 1, 4);
                rc = smb_send_kvec(server, &smb_msg, &sent);
                if (rc < 0)
                        goto uncork;
@@ -329,8 +328,7 @@ __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
                        size += iov[i].iov_len;
                }
 
-               iov_iter_kvec(&smb_msg.msg_iter, WRITE | ITER_KVEC,
-                             iov, n_vec, size);
+               iov_iter_kvec(&smb_msg.msg_iter, WRITE, iov, n_vec, size);
 
                rc = smb_send_kvec(server, &smb_msg, &sent);
                if (rc < 0)
@@ -346,7 +344,7 @@ __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
                        rqst_page_get_length(&rqst[j], i, &bvec.bv_len,
                                             &bvec.bv_offset);
 
-                       iov_iter_bvec(&smb_msg.msg_iter, WRITE | ITER_BVEC,
+                       iov_iter_bvec(&smb_msg.msg_iter, WRITE,
                                      &bvec, 1, bvec.bv_len);
                        rc = smb_send_kvec(server, &smb_msg, &sent);
                        if (rc < 0)

diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index a5e4a221435c04bdf97e1219ca3bd022ca864e6c..76976d6e50f93ac4fad8be97ab0566bcfce6c775 100644 (file)
--- a/fs/dlm/lowcomms.c
+++ b/fs/dlm/lowcomms.c
@@ -674,7 +674,7 @@ static int receive_from_sock(struct connection *con)
                nvec = 2;
        }
        len = iov[0].iov_len + iov[1].iov_len;
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, iov, nvec, len);
+       iov_iter_kvec(&msg.msg_iter, READ, iov, nvec, len);
 
        r = ret = sock_recvmsg(con->sock, &msg, MSG_DONTWAIT | MSG_NOSIGNAL);
        if (ret <= 0)

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index b53e76391e52539d11daee791bc47cc07b2ae773..8b90f54809047acae5c0072281db836dc84df172 100644 (file)
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -923,7 +923,7 @@ __be32 nfsd_readv(struct svc_rqst *rqstp, struct svc_fh *fhp,
        int host_err;
 
        trace_nfsd_read_vector(rqstp, fhp, offset, *count);
-       iov_iter_kvec(&iter, READ | ITER_KVEC, vec, vlen, *count);
+       iov_iter_kvec(&iter, READ, vec, vlen, *count);
        host_err = vfs_iter_read(file, &iter, &offset, 0);
        return nfsd_finish_read(rqstp, fhp, file, offset, count, host_err);
 }
@@ -999,7 +999,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
        if (stable && !use_wgather)
                flags |= RWF_SYNC;
 
-       iov_iter_kvec(&iter, WRITE | ITER_KVEC, vec, vlen, *cnt);
+       iov_iter_kvec(&iter, WRITE, vec, vlen, *cnt);
        host_err = vfs_iter_write(file, &iter, &pos, flags);
        if (host_err < 0)
                goto out_nfserr;

diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 7d9eea7d4a87339a58a1f17066c476af59d93642..e9f236af1927d3aaf4bf495ae4a35234c5c94041 100644 (file)
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -916,7 +916,7 @@ static int o2net_recv_tcp_msg(struct socket *sock, void *data, size_t len)
 {
        struct kvec vec = { .iov_len = len, .iov_base = data, };
        struct msghdr msg = { .msg_flags = MSG_DONTWAIT, };
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1, len);
+       iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, len);
        return sock_recvmsg(sock, &msg, MSG_DONTWAIT);
 }
 

diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c
index 31932879b7162d12e751aa27b3abfb837b98e90a..136a8bdc1d910194c0b0c0e52f43e18ca5b06d4f 100644 (file)
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -25,7 +25,7 @@ static int read_one_page(struct page *page)
        struct iov_iter to;
        struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
 
-       iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
+       iov_iter_bvec(&to, READ, &bv, 1, PAGE_SIZE);
 
        gossip_debug(GOSSIP_INODE_DEBUG,
                    "orangefs_readpage called with page %p\n",

diff --git a/fs/splice.c b/fs/splice.c
index b3daa971f59771d6adf248a192db7d6e3121b015..3553f1956508daeca04aa1acaa1aaab61cdbb6e5 100644 (file)
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -301,7 +301,7 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
        struct kiocb kiocb;
        int idx, ret;
 
-       iov_iter_pipe(&to, ITER_PIPE | READ, pipe, len);
+       iov_iter_pipe(&to, READ, pipe, len);
        idx = to.idx;
        init_sync_kiocb(&kiocb, in);
        kiocb.ki_pos = *ppos;
@@ -386,7 +386,7 @@ static ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
         */
        offset = *ppos & ~PAGE_MASK;
 
-       iov_iter_pipe(&to, ITER_PIPE | READ, pipe, len + offset);
+       iov_iter_pipe(&to, READ, pipe, len + offset);
 
        res = iov_iter_get_pages_alloc(&to, &pages, len + offset, &base);
        if (res <= 0)
@@ -745,8 +745,7 @@ iter_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
                        left -= this_len;
                }
 
-               iov_iter_bvec(&from, ITER_BVEC | WRITE, array, n,
-                             sd.total_len - left);
+               iov_iter_bvec(&from, WRITE, array, n, sd.total_len - left);
                ret = vfs_iter_write(out, &from, &sd.pos, 0);
                if (ret <= 0)
                        break;

diff --git a/include/linux/uio.h b/include/linux/uio.h
index fcabc959c794d47be8732c54ff1f43f039e77ddd..3d8f1acc142c2a3b4a700b0b84f20af9965588d9 100644 (file)
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -29,7 +29,7 @@ enum iter_type {
 };
 
 struct iov_iter {
-       int type;
+       unsigned int type;
        size_t iov_offset;
        size_t count;
        union {
@@ -212,13 +212,13 @@ size_t copy_to_iter_mcsafe(void *addr, size_t bytes, struct iov_iter *i)
 size_t iov_iter_zero(size_t bytes, struct iov_iter *);
 unsigned long iov_iter_alignment(const struct iov_iter *i);
 unsigned long iov_iter_gap_alignment(const struct iov_iter *i);
-void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
+void iov_iter_init(struct iov_iter *i, unsigned int direction, const struct iovec *iov,
                        unsigned long nr_segs, size_t count);
-void iov_iter_kvec(struct iov_iter *i, int direction, const struct kvec *kvec,
+void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvec *kvec,
                        unsigned long nr_segs, size_t count);
-void iov_iter_bvec(struct iov_iter *i, int direction, const struct bio_vec *bvec,
+void iov_iter_bvec(struct iov_iter *i, unsigned int direction, const struct bio_vec *bvec,
                        unsigned long nr_segs, size_t count);
-void iov_iter_pipe(struct iov_iter *i, int direction, struct pipe_inode_info *pipe,
+void iov_iter_pipe(struct iov_iter *i, unsigned int direction, struct pipe_inode_info *pipe,
                        size_t count);
 ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
                        size_t maxsize, unsigned maxpages, size_t *start);

diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index 42d39116a5564daf057b6248eb95e433c4c101db..c42b928b15efa158c9e473286fc72698d9f539fc 100644 (file)
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -428,17 +428,19 @@ int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
 }
 EXPORT_SYMBOL(iov_iter_fault_in_readable);
 
-void iov_iter_init(struct iov_iter *i, int direction,
+void iov_iter_init(struct iov_iter *i, unsigned int direction,
                        const struct iovec *iov, unsigned long nr_segs,
                        size_t count)
 {
+       WARN_ON(direction & ~(READ | WRITE));
+       direction &= READ | WRITE;
+
        /* It will get better.  Eventually... */
        if (uaccess_kernel()) {
-               direction |= ITER_KVEC;
-               i->type = direction;
+               i->type = ITER_KVEC | direction;
                i->kvec = (struct kvec *)iov;
        } else {
-               i->type = direction;
+               i->type = ITER_IOVEC | direction;
                i->iov = iov;
        }
        i->nr_segs = nr_segs;
@@ -1060,12 +1062,12 @@ size_t iov_iter_single_seg_count(const struct iov_iter *i)
 }
 EXPORT_SYMBOL(iov_iter_single_seg_count);
 
-void iov_iter_kvec(struct iov_iter *i, int direction,
+void iov_iter_kvec(struct iov_iter *i, unsigned int direction,
                        const struct kvec *kvec, unsigned long nr_segs,
                        size_t count)
 {
-       BUG_ON(!(direction & ITER_KVEC));
-       i->type = direction;
+       WARN_ON(direction & ~(READ | WRITE));
+       i->type = ITER_KVEC | (direction & (READ | WRITE));
        i->kvec = kvec;
        i->nr_segs = nr_segs;
        i->iov_offset = 0;
@@ -1073,12 +1075,12 @@ void iov_iter_kvec(struct iov_iter *i, int direction,
 }
 EXPORT_SYMBOL(iov_iter_kvec);
 
-void iov_iter_bvec(struct iov_iter *i, int direction,
+void iov_iter_bvec(struct iov_iter *i, unsigned int direction,
                        const struct bio_vec *bvec, unsigned long nr_segs,
                        size_t count)
 {
-       BUG_ON(!(direction & ITER_BVEC));
-       i->type = direction;
+       WARN_ON(direction & ~(READ | WRITE));
+       i->type = ITER_BVEC | (direction & (READ | WRITE));
        i->bvec = bvec;
        i->nr_segs = nr_segs;
        i->iov_offset = 0;
@@ -1086,13 +1088,13 @@ void iov_iter_bvec(struct iov_iter *i, int direction,
 }
 EXPORT_SYMBOL(iov_iter_bvec);
 
-void iov_iter_pipe(struct iov_iter *i, int direction,
+void iov_iter_pipe(struct iov_iter *i, unsigned int direction,
                        struct pipe_inode_info *pipe,
                        size_t count)
 {
-       BUG_ON(direction != ITER_PIPE);
+       BUG_ON(direction != READ);
        WARN_ON(pipe->nrbufs == pipe->buffers);
-       i->type = direction;
+       i->type = ITER_PIPE | READ;
        i->pipe = pipe;
        i->idx = (pipe->curbuf + pipe->nrbufs) & (pipe->buffers - 1);
        i->iov_offset = 0;

diff --git a/mm/page_io.c b/mm/page_io.c
index aafd19ec1db4667b5924b147d506d7eeeef37270..86de453a60cf8bae62bdf7f617a9ab26be796e90 100644 (file)
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -294,7 +294,7 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
                };
                struct iov_iter from;
 
-               iov_iter_bvec(&from, ITER_BVEC | WRITE, &bv, 1, PAGE_SIZE);
+               iov_iter_bvec(&from, WRITE, &bv, 1, PAGE_SIZE);
                init_sync_kiocb(&kiocb, swap_file);
                kiocb.ki_pos = page_file_offset(page);
 

diff --git a/net/9p/client.c b/net/9p/client.c
index deae53a7dffc868d66efbcc01bba141b97d97128..a9cd1401bd0984795ba905174c881285162838be 100644 (file)
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -2070,7 +2070,7 @@ int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
        struct kvec kv = {.iov_base = data, .iov_len = count};
        struct iov_iter to;
 
-       iov_iter_kvec(&to, READ | ITER_KVEC, &kv, 1, count);
+       iov_iter_kvec(&to, READ, &kv, 1, count);
 
        p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
                                fid->fid, (unsigned long long) offset, count);

diff --git a/net/bluetooth/6lowpan.c b/net/bluetooth/6lowpan.c
index 4e2576fc0c59932cbb1f3c98c150764b91bb52c1..828e87fe802788d13f13f39efc68ce7558dfb245 100644 (file)
--- a/net/bluetooth/6lowpan.c
+++ b/net/bluetooth/6lowpan.c
@@ -467,7 +467,7 @@ static int send_pkt(struct l2cap_chan *chan, struct sk_buff *skb,
        iv.iov_len = skb->len;
 
        memset(&msg, 0, sizeof(msg));
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, &iv, 1, skb->len);
+       iov_iter_kvec(&msg.msg_iter, WRITE, &iv, 1, skb->len);
 
        err = l2cap_chan_send(chan, &msg, skb->len);
        if (err > 0) {

diff --git a/net/bluetooth/a2mp.c b/net/bluetooth/a2mp.c
index 51c2cf2d8923ae8dcb174355f26b0b08634a3892..58fc6333d41225dcb967052eec798af839013e0b 100644 (file)
--- a/net/bluetooth/a2mp.c
+++ b/net/bluetooth/a2mp.c
@@ -63,7 +63,7 @@ static void a2mp_send(struct amp_mgr *mgr, u8 code, u8 ident, u16 len, void *dat
 
        memset(&msg, 0, sizeof(msg));
 
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, &iv, 1, total_len);
+       iov_iter_kvec(&msg.msg_iter, WRITE, &iv, 1, total_len);
 
        l2cap_chan_send(chan, &msg, total_len);
 

diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index a1c1b7e8a45ca6d6c44de507d7a5ff232d776edc..c822e626761bd0ecb51e1b1de1f8dfa5b98b3568 100644 (file)
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -622,7 +622,7 @@ static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 
        memset(&msg, 0, sizeof(msg));
 
-       iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iv, 2, 1 + len);
+       iov_iter_kvec(&msg.msg_iter, WRITE, iv, 2, 1 + len);
 
        l2cap_chan_send(chan, &msg, 1 + len);
 

diff --git a/net/ceph/messenger.c b/net/ceph/messenger.c
index 0a187196aeede6375b817a102890f024b552bc3f..e493ff77b378c9c3f5782f0a8ee68630ba854815 100644 (file)
--- a/net/ceph/messenger.c
+++ b/net/ceph/messenger.c
@@ -526,7 +526,7 @@ static int ceph_tcp_recvmsg(struct socket *sock, void *buf, size_t len)
        if (!buf)
                msg.msg_flags |= MSG_TRUNC;
 
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, len);
+       iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, len);
        r = sock_recvmsg(sock, &msg, msg.msg_flags);
        if (r == -EAGAIN)
                r = 0;
@@ -545,7 +545,7 @@ static int ceph_tcp_recvpage(struct socket *sock, struct page *page,
        int r;
 
        BUG_ON(page_offset + length > PAGE_SIZE);
-       iov_iter_bvec(&msg.msg_iter, READ | ITER_BVEC, &bvec, 1, length);
+       iov_iter_bvec(&msg.msg_iter, READ, &bvec, 1, length);
        r = sock_recvmsg(sock, &msg, msg.msg_flags);
        if (r == -EAGAIN)
                r = 0;
@@ -607,7 +607,7 @@ static int ceph_tcp_sendpage(struct socket *sock, struct page *page,
        else
                msg.msg_flags |= MSG_EOR;  /* superfluous, but what the hell */
 
-       iov_iter_bvec(&msg.msg_iter, WRITE | ITER_BVEC, &bvec, 1, size);
+       iov_iter_bvec(&msg.msg_iter, WRITE, &bvec, 1, size);
        ret = sock_sendmsg(sock, &msg);
        if (ret == -EAGAIN)
                ret = 0;

diff --git a/net/netfilter/ipvs/ip_vs_sync.c b/net/netfilter/ipvs/ip_vs_sync.c
index d4020c5e831d3020a6e412ead6d1895f81b5a124..2526be6b3d9095abea1ee68bda4e4f3bf608be55 100644 (file)
--- a/net/netfilter/ipvs/ip_vs_sync.c
+++ b/net/netfilter/ipvs/ip_vs_sync.c
@@ -1616,7 +1616,7 @@ ip_vs_receive(struct socket *sock, char *buffer, const size_t buflen)
        EnterFunction(7);
 
        /* Receive a packet */
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, buflen);
+       iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, buflen);
        len = sock_recvmsg(sock, &msg, MSG_DONTWAIT);
        if (len < 0)
                return len;

diff --git a/net/smc/smc_clc.c b/net/smc/smc_clc.c
index 52241d679cc91cd3b6ec59a4388d33b68c76f1f1..89c3a8c7859a3ae11a63d8db5e8b42e0ca26a897 100644 (file)
--- a/net/smc/smc_clc.c
+++ b/net/smc/smc_clc.c
@@ -286,7 +286,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
         */
        krflags = MSG_PEEK | MSG_WAITALL;
        smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1,
+       iov_iter_kvec(&msg.msg_iter, READ, &vec, 1,
                        sizeof(struct smc_clc_msg_hdr));
        len = sock_recvmsg(smc->clcsock, &msg, krflags);
        if (signal_pending(current)) {
@@ -325,7 +325,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
 
        /* receive the complete CLC message */
        memset(&msg, 0, sizeof(struct msghdr));
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1, datlen);
+       iov_iter_kvec(&msg.msg_iter, READ, &vec, 1, datlen);
        krflags = MSG_WAITALL;
        len = sock_recvmsg(smc->clcsock, &msg, krflags);
        if (len < datlen || !smc_clc_msg_hdr_valid(clcm)) {

diff --git a/net/socket.c b/net/socket.c
index b68801c7d0ab09e69492073e7ce85ed505845216..fae408abea547c9c2bb99daa5308f7cbee06bf24 100644 (file)
--- a/net/socket.c
+++ b/net/socket.c
@@ -635,7 +635,7 @@ EXPORT_SYMBOL(sock_sendmsg);
 int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
                   struct kvec *vec, size_t num, size_t size)
 {
-       iov_iter_kvec(&msg->msg_iter, WRITE | ITER_KVEC, vec, num, size);
+       iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);
        return sock_sendmsg(sock, msg);
 }
 EXPORT_SYMBOL(kernel_sendmsg);
@@ -648,7 +648,7 @@ int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg,
        if (!sock->ops->sendmsg_locked)
                return sock_no_sendmsg_locked(sk, msg, size);
 
-       iov_iter_kvec(&msg->msg_iter, WRITE | ITER_KVEC, vec, num, size);
+       iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);
 
        return sock->ops->sendmsg_locked(sk, msg, msg_data_left(msg));
 }
@@ -823,7 +823,7 @@ int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
        mm_segment_t oldfs = get_fs();
        int result;
 
-       iov_iter_kvec(&msg->msg_iter, READ | ITER_KVEC, vec, num, size);
+       iov_iter_kvec(&msg->msg_iter, READ, vec, num, size);
        set_fs(KERNEL_DS);
        result = sock_recvmsg(sock, msg, flags);
        set_fs(oldfs);

diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 5445145e639c9c82f8cc53f80b327da9260b0658..0b46ec0bf74e8e924be78a43c71421e48eb69eac 100644 (file)
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -338,7 +338,7 @@ static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr,
        rqstp->rq_xprt_hlen = 0;
 
        clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, iov, nr, buflen);
+       iov_iter_kvec(&msg.msg_iter, READ, iov, nr, buflen);
        len = sock_recvmsg(svsk->sk_sock, &msg, msg.msg_flags);
        /* If we read a full record, then assume there may be more
         * data to read (stream based sockets only!)

diff --git a/net/tipc/topsrv.c b/net/tipc/topsrv.c
index d8956f7daac417cfeafd9a97e85575f714417c0b..afa02eeec403456afa877fae9cbe9887a1ea344c 100644 (file)
--- a/net/tipc/topsrv.c
+++ b/net/tipc/topsrv.c
@@ -394,7 +394,7 @@ static int tipc_conn_rcv_from_sock(struct tipc_conn *con)
        iov.iov_base = &s;
        iov.iov_len = sizeof(s);
        msg.msg_name = NULL;
-       iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, iov.iov_len);
+       iov_iter_kvec(&msg.msg_iter, READ, &iov, 1, iov.iov_len);
        ret = sock_recvmsg(con->sock, &msg, MSG_DONTWAIT);
        if (ret == -EWOULDBLOCK)
                return -EWOULDBLOCK;

diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c
index 276edbc04f3859efe96540e8e4705e730bcba56f..d753e362d2d9e625b9d9c4c476cc06cdcbc5430a 100644 (file)
--- a/net/tls/tls_device.c
+++ b/net/tls/tls_device.c
@@ -489,7 +489,7 @@ int tls_device_sendpage(struct sock *sk, struct page *page,
 
        iov.iov_base = kaddr + offset;
        iov.iov_len = size;
-       iov_iter_kvec(&msg_iter, WRITE | ITER_KVEC, &iov, 1, size);
+       iov_iter_kvec(&msg_iter, WRITE, &iov, 1, size);
        rc = tls_push_data(sk, &msg_iter, size,
                           flags, TLS_RECORD_TYPE_DATA);
        kunmap(page);
@@ -538,7 +538,7 @@ static int tls_device_push_pending_record(struct sock *sk, int flags)
 {
        struct iov_iter msg_iter;
 
-       iov_iter_kvec(&msg_iter, WRITE | ITER_KVEC, NULL, 0, 0);
+       iov_iter_kvec(&msg_iter, WRITE, NULL, 0, 0);
        return tls_push_data(sk, &msg_iter, 0, flags, TLS_RECORD_TYPE_DATA);
 }