LU-13814 clio: rename pvec to cdp

Pvec is an older naming convention that sort of matches a
convention used in the kernel, but is really starting to
feel odd as a local variable name for cl_dio_pages.

Rename accordingly.

Test-Parameters: trivial
Signed-off-by: Patrick Farrell <patrick.farrell@oracle.com>
Change-Id: I375b80e4e50dcb2aa7c640df32a8fe896e5fc082
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/52492
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Reviewed-by: Timothy Day <timday@amazon.com>
Reviewed-by: Sebastien Buisson <sbuisson@ddn.com>

diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c
index 8ac7df3..697be18 100644 (file)
--- a/lustre/llite/rw26.c
+++ b/lustre/llite/rw26.c
@@ -243,17 +243,17 @@ static int ll_releasepage(struct page *vmpage, RELEASEPAGE_ARG_TYPE gfp_mask)
 #endif /* HAVE_AOPS_RELEASE_FOLIO */
 
 static ssize_t ll_get_user_pages(int rw, struct iov_iter *iter,
-                               struct cl_dio_pages *pvec,
+                               struct cl_dio_pages *cdp,
                                size_t maxsize)
 {
 #if defined(HAVE_DIO_ITER)
        size_t start;
        size_t result;
 
-       result = iov_iter_get_pages_alloc2(iter, &pvec->cdp_pages, maxsize,
+       result = iov_iter_get_pages_alloc2(iter, &cdp->cdp_pages, maxsize,
                                          &start);
        if (result > 0) {
-               pvec->cdp_count = DIV_ROUND_UP(result + start, PAGE_SIZE);
+               cdp->cdp_count = DIV_ROUND_UP(result + start, PAGE_SIZE);
                if (user_backed_iter(iter))
                        iov_iter_revert(iter, result);
        }
@@ -276,25 +276,25 @@ static ssize_t ll_get_user_pages(int rw, struct iov_iter *iter,
 
        size = min_t(size_t, maxsize, iter->iov->iov_len);
        page_count = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-       OBD_ALLOC_PTR_ARRAY_LARGE(pvec->cdp_pages, page_count);
-       if (pvec->cdp_pages == NULL)
+       OBD_ALLOC_PTR_ARRAY_LARGE(cdp->cdp_pages, page_count);
+       if (cdp->cdp_pages == NULL)
                return -ENOMEM;
 
        mmap_read_lock(current->mm);
        result = get_user_pages(current, current->mm, addr, page_count,
-                               rw == READ, 0, pvec->cdp_pages, NULL);
+                               rw == READ, 0, cdp->cdp_pages, NULL);
        mmap_read_unlock(current->mm);
 
        if (unlikely(result != page_count)) {
-               ll_release_user_pages(pvec->cdp_pages, page_count);
-               pvec->cdp_pages = NULL;
+               ll_release_user_pages(cdp->cdp_pages, page_count);
+               cdp->cdp_pages = NULL;
 
                if (result >= 0)
                        return -EFAULT;
 
                return result;
        }
-       pvec->cdp_count = page_count;
+       cdp->cdp_count = page_count;
 
        return size;
 #endif
@@ -373,21 +373,21 @@ static int
 ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, size_t size,
                   int rw, struct inode *inode, struct cl_sub_dio *sdio)
 {
-       struct cl_dio_pages *pv = &sdio->csd_dio_pages;
+       struct cl_dio_pages *cdp = &sdio->csd_dio_pages;
        struct cl_sync_io *anchor = &sdio->csd_sync;
        struct cl_2queue *queue = &io->ci_queue;
        struct cl_object *obj = io->ci_obj;
        struct cl_page *page;
        int iot = rw == READ ? CRT_READ : CRT_WRITE;
-       loff_t offset = pv->cdp_file_offset;
+       loff_t offset = cdp->cdp_file_offset;
        int io_pages = 0;
        ssize_t rc = 0;
        int i = 0;
 
        ENTRY;
 
-       pv->cdp_from = offset & ~PAGE_MASK;
-       pv->cdp_to = (offset + size) & ~PAGE_MASK;
+       cdp->cdp_from = offset & ~PAGE_MASK;
+       cdp->cdp_to = (offset + size) & ~PAGE_MASK;
 
        cl_2queue_init(queue);
        while (size > 0) {
@@ -395,7 +395,7 @@ ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, size_t size,
                size_t to = min(from + size, PAGE_SIZE);
 
                page = cl_page_find(env, obj, offset >> PAGE_SHIFT,
-                                   pv->cdp_pages[i], CPT_TRANSIENT);
+                                   cdp->cdp_pages[i], CPT_TRANSIENT);
                if (IS_ERR(page))
                        GOTO(out, rc = PTR_ERR(page));
 
@@ -429,10 +429,10 @@ ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, size_t size,
                offset += to - from;
                size -= to - from;
        }
-       /* on success, we should hit every page in the pvec and have no bytes
+       /* on success, we should hit every page in the cdp and have no bytes
         * left in 'size'
         */
-       LASSERT(i == pv->cdp_count);
+       LASSERT(i == cdp->cdp_count);
        LASSERT(size == 0);
 
        atomic_add(io_pages, &anchor->csi_sync_nr);
@@ -584,7 +584,7 @@ ll_direct_IO_impl(struct kiocb *iocb, struct iov_iter *iter, int rw)
                sync_submit = true;
 
        while (iov_iter_count(iter)) {
-               struct cl_dio_pages *pvec;
+               struct cl_dio_pages *cdp;
 
                count = min_t(size_t, iov_iter_count(iter), MAX_DIO_SIZE);
                if (rw == READ) {
@@ -604,11 +604,11 @@ ll_direct_IO_impl(struct kiocb *iocb, struct iov_iter *iter, int rw)
                if (!sdio)
                        GOTO(out, result = -ENOMEM);
 
-               pvec = &sdio->csd_dio_pages;
-               pvec->cdp_file_offset = file_offset;
+               cdp = &sdio->csd_dio_pages;
+               cdp->cdp_file_offset = file_offset;
 
                if (!unaligned) {
-                       result = ll_get_user_pages(rw, iter, pvec, count);
+                       result = ll_get_user_pages(rw, iter, cdp, count);
                        /* ll_get_user_pages returns bytes in the IO or error*/
                        count = result;
                } else {
@@ -618,7 +618,7 @@ ll_direct_IO_impl(struct kiocb *iocb, struct iov_iter *iter, int rw)
 
                        /* same calculation used in ll_get_user_pages */
                        count = min_t(size_t, count, len);
-                       result = ll_allocate_dio_buffer(pvec, count);
+                       result = ll_allocate_dio_buffer(cdp, count);
                        /* allocate_dio_buffer returns number of pages or
                         * error, so do not set count = result
                         */

diff --git a/lustre/obdclass/cl_io.c b/lustre/obdclass/cl_io.c
index 81d7fec..b4da6d5 100644 (file)
--- a/lustre/obdclass/cl_io.c
+++ b/lustre/obdclass/cl_io.c
@@ -1365,7 +1365,7 @@ EXPORT_SYMBOL(cl_sub_dio_free);
  * hold it.  The pages in this buffer are aligned with pages in the file (ie,
  * they have a 1-to-1 mapping with file pages).
  */
-int ll_allocate_dio_buffer(struct cl_dio_pages *pvec, size_t io_size)
+int ll_allocate_dio_buffer(struct cl_dio_pages *cdp, size_t io_size)
 {
        size_t pg_offset;
        int result = 0;
@@ -1373,52 +1373,52 @@ int ll_allocate_dio_buffer(struct cl_dio_pages *pvec, size_t io_size)
        ENTRY;
 
        /* page level offset in the file where the I/O starts */
-       pg_offset = pvec->cdp_file_offset & ~PAGE_MASK;
+       pg_offset = cdp->cdp_file_offset & ~PAGE_MASK;
        /* this adds 1 for the first page and removes the bytes in it from the
         * io_size, making the rest of the calculation aligned
         */
        if (pg_offset) {
-               pvec->cdp_count++;
+               cdp->cdp_count++;
                io_size -= min_t(size_t, PAGE_SIZE - pg_offset, io_size);
        }
 
        /* calculate pages for the rest of the buffer */
-       pvec->cdp_count += (io_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       cdp->cdp_count += (io_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 
 #ifdef HAVE_DIO_ITER
-       pvec->cdp_pages = kvzalloc(pvec->cdp_count * sizeof(struct page *),
-                                   GFP_NOFS);
+       cdp->cdp_pages = kvzalloc(cdp->cdp_count * sizeof(struct page *),
+                                 GFP_NOFS);
 #else
-       OBD_ALLOC_PTR_ARRAY_LARGE(pvec->cdp_pages, pvec->cdp_count);
+       OBD_ALLOC_PTR_ARRAY_LARGE(cdp->cdp_pages, cdp->cdp_count);
 #endif
-       if (pvec->cdp_pages == NULL)
+       if (cdp->cdp_pages == NULL)
                GOTO(out, result = -ENOMEM);
 
-       result = obd_pool_get_pages_array(pvec->cdp_pages, pvec->cdp_count);
+       result = obd_pool_get_pages_array(cdp->cdp_pages, cdp->cdp_count);
        if (result)
                GOTO(out, result);
 
 out:
        if (result) {
-               if (pvec->cdp_pages)
-                       ll_free_dio_buffer(pvec);
+               if (cdp->cdp_pages)
+                       ll_free_dio_buffer(cdp);
        }
 
        if (result == 0)
-               result = pvec->cdp_count;
+               result = cdp->cdp_count;
 
        RETURN(result);
 }
 EXPORT_SYMBOL(ll_allocate_dio_buffer);
 
-void ll_free_dio_buffer(struct cl_dio_pages *pvec)
+void ll_free_dio_buffer(struct cl_dio_pages *cdp)
 {
-       obd_pool_put_pages_array(pvec->cdp_pages, pvec->cdp_count);
+       obd_pool_put_pages_array(cdp->cdp_pages, cdp->cdp_count);
 
 #ifdef HAVE_DIO_ITER
-       kvfree(pvec->cdp_pages);
+       kvfree(cdp->cdp_pages);
 #else
-       OBD_FREE_PTR_ARRAY_LARGE(pvec->cdp_pages, pvec->cdp_count);
+       OBD_FREE_PTR_ARRAY_LARGE(cdp->cdp_pages, cdp->cdp_count);
 #endif
 }
 EXPORT_SYMBOL(ll_free_dio_buffer);
@@ -1467,9 +1467,9 @@ EXPORT_SYMBOL(ll_release_user_pages);
 static ssize_t __ll_dio_user_copy(struct cl_sub_dio *sdio)
 {
        struct iov_iter *iter = &sdio->csd_iter;
-       struct cl_dio_pages *pvec = &sdio->csd_dio_pages;
+       struct cl_dio_pages *cdp = &sdio->csd_dio_pages;
        struct mm_struct *mm = sdio->csd_ll_aio->cda_mm;
-       loff_t pos = pvec->cdp_file_offset;
+       loff_t pos = cdp->cdp_file_offset;
        size_t count = sdio->csd_bytes;
        size_t original_count = count;
        int short_copies = 0;
@@ -1531,19 +1531,19 @@ static ssize_t __ll_dio_user_copy(struct cl_sub_dio *sdio)
         * at the iovec
         */
        while (true) {
-               struct page *page = pvec->cdp_pages[i];
+               struct page *page = cdp->cdp_pages[i];
                unsigned long offset; /* offset into kernel buffer page */
                size_t copied; /* bytes successfully copied */
                size_t bytes; /* bytes to copy for this page */
 
-               LASSERT(i < pvec->cdp_count);
+               LASSERT(i < cdp->cdp_count);
 
                offset = pos & ~PAGE_MASK;
                bytes = min_t(unsigned long, PAGE_SIZE - offset, count);
 
                CDEBUG(D_VFSTRACE,
                       "count %zd, offset %lu, pos %lld, cdp_count %lu\n",
-                      count, offset, pos, pvec->cdp_count);
+                      count, offset, pos, cdp->cdp_count);
 
                if (fatal_signal_pending(current)) {
                        status = -EINTR;
@@ -1612,9 +1612,9 @@ static ssize_t __ll_dio_user_copy(struct cl_sub_dio *sdio)
                sdio->csd_write_copied = true;
 
        /* if we complete successfully, we should reach all of the pages */
-       LASSERTF(ergo(status == 0, i == pvec->cdp_count - 1),
-                "status: %d, i: %d, pvec->cdp_count %zu, count %zu\n",
-                 status, i, pvec->cdp_count, count);
+       LASSERTF(ergo(status == 0, i == cdp->cdp_count - 1),
+                "status: %d, i: %d, cdp->cdp_count %zu, count %zu\n",
+                 status, i, cdp->cdp_count, count);
 
 out:
        if (mm_used)