LU-13814 clio: rename ll_dio_pages to cl_dio_pages

ll_dio_pages was originally mostly used in the llite layer,
but its usage is now expanding throughout clio.

Rename it accordingly.

Test-Parameters: trivial
Test-Parameters: forjanitoronly
Signed-off-by: Patrick Farrell <pfarrell@whamcloud.com>
Change-Id: Id52ded6231510bb16eaf98b08f2eb2146b7ac582

diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h
index 7f75148..50da22c 100644 (file)
--- a/lustre/include/cl_object.h
+++ b/lustre/include/cl_object.h
@@ -2560,21 +2560,21 @@ struct cl_sync_io {
 };
 
 /** direct IO pages */
-struct ll_dio_pages {
+struct cl_dio_pages {
        /*
         * page array for RDMA - for aligned i/o, this is the user provided
         * pages, but for unaligned i/o, this is the internal buffer
         */
-       struct page             **ldp_pages;
+       struct page             **cdp_pages;
        /** # of pages in the array. */
-       size_t                  ldp_count;
+       size_t                  cdp_count;
        /* the file offset of the first page. */
-       loff_t                  ldp_file_offset;
+       loff_t                  cdp_file_offset;
        /* the first and last page can be incomplete, this records the
         * offsets
         */
-       int                     ldp_from;
-       int                     ldp_to;
+       int                     cdp_from;
+       int                     cdp_to;
 };
 
 /* Top level struct used for AIO and DIO */
@@ -2596,7 +2596,7 @@ struct cl_sub_dio {
        struct cl_page_list     csd_pages;
        ssize_t                 csd_bytes;
        struct cl_dio_aio       *csd_ll_aio;
-       struct ll_dio_pages     csd_dio_pages;
+       struct cl_dio_pages     csd_dio_pages;
        struct iov_iter         csd_iter;
        unsigned                csd_creator_free:1,
                                csd_write:1,
@@ -2608,8 +2608,8 @@ struct cl_sub_dio {
 #endif
 
 void ll_release_user_pages(struct page **pages, int npages);
-int ll_allocate_dio_buffer(struct ll_dio_pages *pvec, size_t io_size);
-void ll_free_dio_buffer(struct ll_dio_pages *pvec);
+int ll_allocate_dio_buffer(struct cl_dio_pages *cdp, size_t io_size);
+void ll_free_dio_buffer(struct cl_dio_pages *cdp);
 ssize_t ll_dio_user_copy(struct cl_sub_dio *sdio, struct iov_iter *write_iov);
 
 #ifndef HAVE_KTHREAD_USE_MM

diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c
index 04c1b98..8f1b670 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 ll_dio_pages *pvec,
-                               size_t maxsize)
+                                struct cl_dio_pages *pvec,
+                                size_t maxsize)
 {
 #if defined(HAVE_DIO_ITER)
        size_t start;
        size_t result;
 
-       result = iov_iter_get_pages_alloc2(iter, &pvec->ldp_pages, maxsize,
+       result = iov_iter_get_pages_alloc2(iter, &pvec->cdp_pages, maxsize,
                                          &start);
        if (result > 0)
-               pvec->ldp_count = DIV_ROUND_UP(result + start, PAGE_SIZE);
+               pvec->cdp_count = DIV_ROUND_UP(result + start, PAGE_SIZE);
 
        return result;
 #else
@@ -274,25 +274,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->ldp_pages, page_count);
-       if (pvec->ldp_pages == NULL)
+       OBD_ALLOC_PTR_ARRAY_LARGE(pvec->cdp_pages, page_count);
+       if (pvec->cdp_pages == NULL)
                return -ENOMEM;
 
        mmap_read_lock(current->mm);
        result = get_user_pages(current, current->mm, addr, page_count,
-                               rw == READ, 0, pvec->ldp_pages, NULL);
+                               rw == READ, 0, pvec->cdp_pages, NULL);
        mmap_read_unlock(current->mm);
 
        if (unlikely(result != page_count)) {
-               ll_release_user_pages(pvec->ldp_pages, page_count);
-               pvec->ldp_pages = NULL;
+               ll_release_user_pages(pvec->cdp_pages, page_count);
+               pvec->cdp_pages = NULL;
 
                if (result >= 0)
                        return -EFAULT;
 
                return result;
        }
-       pvec->ldp_count = page_count;
+       pvec->cdp_count = page_count;
 
        return size;
 #endif
@@ -365,21 +365,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 ll_dio_pages *pv = &sdio->csd_dio_pages;
+       struct cl_dio_pages *pv = &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->ldp_file_offset;
+       loff_t offset = pv->cdp_file_offset;
        int io_pages = 0;
        ssize_t rc = 0;
        int i = 0;
 
        ENTRY;
 
-       pv->ldp_from = offset & ~PAGE_MASK;
-       pv->ldp_to = (offset + size) & ~PAGE_MASK;
+       pv->cdp_from = offset & ~PAGE_MASK;
+       pv->cdp_to = (offset + size) & ~PAGE_MASK;
 
        cl_2queue_init(queue);
        while (size > 0) {
@@ -387,7 +387,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, io, obj, offset >> PAGE_SHIFT,
-                                   pv->ldp_pages[i], CPT_TRANSIENT);
+                                   pv->cdp_pages[i], CPT_TRANSIENT);
                if (IS_ERR(page))
                        GOTO(out, rc = PTR_ERR(page));
 
@@ -424,7 +424,7 @@ ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, size_t size,
        /* on success, we should hit every page in the pvec and have no bytes
         * left in 'size'
         */
-       LASSERT(i == pv->ldp_count);
+       LASSERT(i == pv->cdp_count);
        LASSERT(size == 0);
 
        atomic_add(io_pages, &anchor->csi_sync_nr);
@@ -573,7 +573,7 @@ ll_direct_IO_impl(struct kiocb *iocb, struct iov_iter *iter, int rw)
                sync_submit = true;
 
        while (iov_iter_count(iter)) {
-               struct ll_dio_pages *pvec;
+               struct cl_dio_pages *pvec;
 
                count = min_t(size_t, iov_iter_count(iter), MAX_DIO_SIZE);
                if (rw == READ) {
@@ -594,7 +594,7 @@ ll_direct_IO_impl(struct kiocb *iocb, struct iov_iter *iter, int rw)
                        GOTO(out, result = -ENOMEM);
 
                pvec = &sdio->csd_dio_pages;
-               pvec->ldp_file_offset = file_offset;
+               pvec->cdp_file_offset = file_offset;
 
                if (!unaligned) {
                        result = ll_get_user_pages(rw, iter, pvec, count);

diff --git a/lustre/obdclass/cl_io.c b/lustre/obdclass/cl_io.c
index a1866f5..5ccee3f 100644 (file)
--- a/lustre/obdclass/cl_io.c
+++ b/lustre/obdclass/cl_io.c
@@ -1242,8 +1242,8 @@ static void cl_sub_dio_end(const struct lu_env *env, struct cl_sync_io *anchor)
                /* unaligned DIO does not get user pages, so it doesn't have to
                 * release them, but aligned I/O must
                 */
-               ll_release_user_pages(sdio->csd_dio_pages.ldp_pages,
-                                     sdio->csd_dio_pages.ldp_count);
+               ll_release_user_pages(sdio->csd_dio_pages.cdp_pages,
+                                     sdio->csd_dio_pages.cdp_count);
        }
        cl_sync_io_note(env, &sdio->csd_ll_aio->cda_sync, ret);
 
@@ -1364,7 +1364,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 ll_dio_pages *pvec, size_t io_size)
+int ll_allocate_dio_buffer(struct cl_dio_pages *pvec, size_t io_size)
 {
        struct page *new_page;
        size_t pg_offset;
@@ -1374,62 +1374,62 @@ int ll_allocate_dio_buffer(struct ll_dio_pages *pvec, size_t io_size)
        ENTRY;
 
        /* page level offset in the file where the I/O starts */
-       pg_offset = pvec->ldp_file_offset & ~PAGE_MASK;
+       pg_offset = pvec->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->ldp_count++;
+               pvec->cdp_count++;
                io_size -= min_t(size_t, PAGE_SIZE - pg_offset, io_size);
        }
 
        /* calculate pages for the rest of the buffer */
-       pvec->ldp_count += (io_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       pvec->cdp_count += (io_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 
 #ifdef HAVE_DIO_ITER
-       pvec->ldp_pages = kvzalloc(pvec->ldp_count * sizeof(struct page *),
+       pvec->cdp_pages = kvzalloc(pvec->cdp_count * sizeof(struct page *),
                                    GFP_NOFS);
 #else
-       OBD_ALLOC_PTR_ARRAY_LARGE(pvec->ldp_pages, pvec->ldp_count);
+       OBD_ALLOC_PTR_ARRAY_LARGE(pvec->cdp_pages, pvec->cdp_count);
 #endif
-       if (pvec->ldp_pages == NULL)
+       if (pvec->cdp_pages == NULL)
                RETURN(-ENOMEM);
 
-       for (i = 0; i < pvec->ldp_count; i++) {
+       for (i = 0; i < pvec->cdp_count; i++) {
                new_page = alloc_page(GFP_NOFS);
                if (!new_page) {
                        result = -ENOMEM;
-                       pvec->ldp_count = i;
+                       pvec->cdp_count = i;
                        goto out;
                }
-               pvec->ldp_pages[i] = new_page;
+               pvec->cdp_pages[i] = new_page;
        }
-       WARN_ON(i != pvec->ldp_count);
+       WARN_ON(i != pvec->cdp_count);
 
 out:
        if (result) {
-               if (pvec->ldp_pages)
+               if (pvec->cdp_pages)
                        ll_free_dio_buffer(pvec);
        }
 
        if (result == 0)
-               result = pvec->ldp_count;
+               result = pvec->cdp_count;
 
        RETURN(result);
 }
 EXPORT_SYMBOL(ll_allocate_dio_buffer);
 
-void ll_free_dio_buffer(struct ll_dio_pages *pvec)
+void ll_free_dio_buffer(struct cl_dio_pages *pvec)
 {
        int i;
 
-       for (i = 0; i < pvec->ldp_count; i++)
-               __free_page(pvec->ldp_pages[i]);
+       for (i = 0; i < pvec->cdp_count; i++)
+               __free_page(pvec->cdp_pages[i]);
 
 #ifdef HAVE_DIO_ITER
-       kfree(pvec->ldp_pages);
+       kfree(pvec->cdp_pages);
 #else
-       OBD_FREE_PTR_ARRAY_LARGE(pvec->ldp_pages, pvec->ldp_count);
+       OBD_FREE_PTR_ARRAY_LARGE(pvec->cdp_pages, pvec->cdp_count);
 #endif
 }
 EXPORT_SYMBOL(ll_free_dio_buffer);
@@ -1478,9 +1478,9 @@ EXPORT_SYMBOL(ll_release_user_pages);
 ssize_t ll_dio_user_copy(struct cl_sub_dio *sdio, struct iov_iter *write_iov)
 {
        struct iov_iter *iter = write_iov ? write_iov : &sdio->csd_iter;
-       struct ll_dio_pages *pvec = &sdio->csd_dio_pages;
+       struct cl_dio_pages *pvec = &sdio->csd_dio_pages;
        struct mm_struct *mm = sdio->csd_ll_aio->cda_mm;
-       loff_t pos = pvec->ldp_file_offset;
+       loff_t pos = pvec->cdp_file_offset;
        size_t count = sdio->csd_bytes;
        size_t original_count = count;
        int short_copies = 0;
@@ -1524,20 +1524,20 @@ ssize_t ll_dio_user_copy(struct cl_sub_dio *sdio, struct iov_iter *write_iov)
         * at the iovec
         */
        while (true) {
-               struct page *page = pvec->ldp_pages[i];
+               struct page *page = pvec->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->ldp_count);
+               LASSERT(i < pvec->cdp_count);
 
                offset = pos & ~PAGE_MASK;
                bytes = min_t(unsigned long, PAGE_SIZE - offset,
                              count);
 
                CDEBUG(D_VFSTRACE,
-                      "count %zd, offset %lu, pos %lld, ldp_count %lu\n",
-                      count, offset, pos, pvec->ldp_count);
+                      "count %zd, offset %lu, pos %lld, cdp_count %lu\n",
+                      count, offset, pos, pvec->cdp_count);
 
                if (fatal_signal_pending(current)) {
                        status = -EINTR;
@@ -1603,9 +1603,9 @@ ssize_t ll_dio_user_copy(struct cl_sub_dio *sdio, struct iov_iter *write_iov)
 
 out:
        /* if we complete successfully, we should reach all of the pages */
-       LASSERTF(ergo(status == 0, i == pvec->ldp_count - 1),
-                "status: %d, i: %d, pvec->ldp_count %zu, count %zu\n",
-                 status, i, pvec->ldp_count, count);
+       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);
 
        if (write_iov && status == 0) {
                /* The copy function we use modifies the count in the iovec,