iov_iter: Use accessor function

Use accessor functions to access an iterator's type and direction.  This
allows for the possibility of using some other method of determining the
type of iterator than if-chains with bitwise-AND conditions.

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

1 files changed, 28 insertions, 28 deletions

diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index 8be175df3075..42d39116a556 100644
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -558,7 +558,7 @@ static size_t copy_pipe_to_iter(const void *addr, size_t bytes,
 size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 {
         const char *from = addr;
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return copy_pipe_to_iter(addr, bytes, i);
         if (iter_is_iovec(i))
                 might_fault();
@@ -658,7 +658,7 @@ size_t _copy_to_iter_mcsafe(const void *addr, size_t bytes, struct iov_iter *i)
         const char *from = addr;
         unsigned long rem, curr_addr, s_addr = (unsigned long) addr;
 
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return copy_pipe_to_iter_mcsafe(addr, bytes, i);
         if (iter_is_iovec(i))
                 might_fault();
@@ -692,7 +692,7 @@ EXPORT_SYMBOL_GPL(_copy_to_iter_mcsafe);
 size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
 {
         char *to = addr;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return 0;
         }
@@ -712,7 +712,7 @@ EXPORT_SYMBOL(_copy_from_iter);
 bool _copy_from_iter_full(void *addr, size_t bytes, struct iov_iter *i)
 {
         char *to = addr;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return false;
         }
@@ -739,7 +739,7 @@ EXPORT_SYMBOL(_copy_from_iter_full);
 size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
 {
         char *to = addr;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return 0;
         }
@@ -773,7 +773,7 @@ EXPORT_SYMBOL(_copy_from_iter_nocache);
 size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
 {
         char *to = addr;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return 0;
         }
@@ -794,7 +794,7 @@ EXPORT_SYMBOL_GPL(_copy_from_iter_flushcache);
 bool _copy_from_iter_full_nocache(void *addr, size_t bytes, struct iov_iter *i)
 {
         char *to = addr;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return false;
         }
@@ -836,7 +836,7 @@ size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
                 size_t wanted = copy_to_iter(kaddr + offset, bytes, i);
                 kunmap_atomic(kaddr);
                 return wanted;
-        } else if (likely(!(i->type & ITER_PIPE)))
+        } else if (likely(!iov_iter_is_pipe(i)))
                 return copy_page_to_iter_iovec(page, offset, bytes, i);
         else
                 return copy_page_to_iter_pipe(page, offset, bytes, i);
@@ -848,7 +848,7 @@ size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
 {
         if (unlikely(!page_copy_sane(page, offset, bytes)))
                 return 0;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return 0;
         }
@@ -888,7 +888,7 @@ static size_t pipe_zero(size_t bytes, struct iov_iter *i)
 
 size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
 {
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return pipe_zero(bytes, i);
         iterate_and_advance(i, bytes, v,
                 clear_user(v.iov_base, v.iov_len),
@@ -908,7 +908,7 @@ size_t iov_iter_copy_from_user_atomic(struct page *page,
                 kunmap_atomic(kaddr);
                 return 0;
         }
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 kunmap_atomic(kaddr);
                 WARN_ON(1);
                 return 0;
@@ -972,7 +972,7 @@ static void pipe_advance(struct iov_iter *i, size_t size)
 
 void iov_iter_advance(struct iov_iter *i, size_t size)
 {
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 pipe_advance(i, size);
                 return;
         }
@@ -987,7 +987,7 @@ void iov_iter_revert(struct iov_iter *i, size_t unroll)
         if (WARN_ON(unroll > MAX_RW_COUNT))
                 return;
         i->count += unroll;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 struct pipe_inode_info *pipe = i->pipe;
                 int idx = i->idx;
                 size_t off = i->iov_offset;
@@ -1016,7 +1016,7 @@ void iov_iter_revert(struct iov_iter *i, size_t unroll)
                 return;
         }
         unroll -= i->iov_offset;
-        if (i->type & ITER_BVEC) {
+        if (iov_iter_is_bvec(i)) {
                 const struct bio_vec *bvec = i->bvec;
                 while (1) {
                         size_t n = (--bvec)->bv_len;
@@ -1049,11 +1049,11 @@ EXPORT_SYMBOL(iov_iter_revert);
  */
 size_t iov_iter_single_seg_count(const struct iov_iter *i)
 {
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return i->count;        // it is a silly place, anyway
         if (i->nr_segs == 1)
                 return i->count;
-        else if (i->type & ITER_BVEC)
+        else if (iov_iter_is_bvec(i))
                 return min(i->count, i->bvec->bv_len - i->iov_offset);
         else
                 return min(i->count, i->iov->iov_len - i->iov_offset);
@@ -1106,7 +1106,7 @@ unsigned long iov_iter_alignment(const struct iov_iter *i)
         unsigned long res = 0;
         size_t size = i->count;
 
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 if (size && i->iov_offset && allocated(&i->pipe->bufs[i->idx]))
                         return size | i->iov_offset;
                 return size;
@@ -1125,7 +1125,7 @@ unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
         unsigned long res = 0;
         size_t size = i->count;
 
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return ~0U;
         }
@@ -1193,7 +1193,7 @@ ssize_t iov_iter_get_pages(struct iov_iter *i,
         if (maxsize > i->count)
                 maxsize = i->count;
 
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return pipe_get_pages(i, pages, maxsize, maxpages, start);
         iterate_all_kinds(i, maxsize, v, ({
                 unsigned long addr = (unsigned long)v.iov_base;
@@ -1205,7 +1205,7 @@ ssize_t iov_iter_get_pages(struct iov_iter *i,
                         len = maxpages * PAGE_SIZE;
                 addr &= ~(PAGE_SIZE - 1);
                 n = DIV_ROUND_UP(len, PAGE_SIZE);
-                res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, pages);
+                res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, pages);
                 if (unlikely(res < 0))
                         return res;
                 return (res == n ? len : res * PAGE_SIZE) - *start;
@@ -1270,7 +1270,7 @@ ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
         if (maxsize > i->count)
                 maxsize = i->count;
 
-        if (unlikely(i->type & ITER_PIPE))
+        if (unlikely(iov_iter_is_pipe(i)))
                 return pipe_get_pages_alloc(i, pages, maxsize, start);
         iterate_all_kinds(i, maxsize, v, ({
                 unsigned long addr = (unsigned long)v.iov_base;
@@ -1283,7 +1283,7 @@ ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
                 p = get_pages_array(n);
                 if (!p)
                         return -ENOMEM;
-                res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, p);
+                res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, p);
                 if (unlikely(res < 0)) {
                         kvfree(p);
                         return res;
@@ -1313,7 +1313,7 @@ size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
         __wsum sum, next;
         size_t off = 0;
         sum = *csum;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return 0;
         }
@@ -1355,7 +1355,7 @@ bool csum_and_copy_from_iter_full(void *addr, size_t bytes, __wsum *csum,
         __wsum sum, next;
         size_t off = 0;
         sum = *csum;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);
                 return false;
         }
@@ -1400,7 +1400,7 @@ size_t csum_and_copy_to_iter(const void *addr, size_t bytes, __wsum *csum,
         __wsum sum, next;
         size_t off = 0;
         sum = *csum;
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 WARN_ON(1);     /* for now */
                 return 0;
         }
@@ -1443,7 +1443,7 @@ int iov_iter_npages(const struct iov_iter *i, int maxpages)
         if (!size)
                 return 0;
 
-        if (unlikely(i->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(i))) {
                 struct pipe_inode_info *pipe = i->pipe;
                 size_t off;
                 int idx;
@@ -1481,11 +1481,11 @@ EXPORT_SYMBOL(iov_iter_npages);
 const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags)
 {
         *new = *old;
-        if (unlikely(new->type & ITER_PIPE)) {
+        if (unlikely(iov_iter_is_pipe(new))) {
                 WARN_ON(1);
                 return NULL;
         }
-        if (new->type & ITER_BVEC)
+        if (iov_iter_is_bvec(new))
                 return new->bvec = kmemdup(new->bvec,
                                     new->nr_segs * sizeof(struct bio_vec),
                                     flags);