From 92e3aa1aa0e1c3b4e5bb59e1ee223512136cf13e Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Sun, 17 Sep 2023 16:36:59 -0400 Subject: [PATCH] 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 Change-Id: Id52ded6231510bb16eaf98b08f2eb2146b7ac582 --- lustre/include/cl_object.h | 18 +++++++------- lustre/llite/rw26.c | 36 ++++++++++++++-------------- lustre/obdclass/cl_io.c | 58 +++++++++++++++++++++++----------------------- 3 files changed, 56 insertions(+), 56 deletions(-) diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h index 7f75148..50da22c 100644 --- 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 --- 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 --- 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, -- 1.8.3.1