From bbeaceb3ebe2c12903cf5c591e4cd329167de80c Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Fri, 12 Jul 2024 11:56:14 -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 Signed-off-by: Patrick Farrell Change-Id: Id52ded6231510bb16eaf98b08f2eb2146b7ac582 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/52102 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Oleg Drokin Reviewed-by: Qian Yingjin Reviewed-by: Sebastien Buisson --- lustre/include/cl_object.h | 18 ++++++++--------- lustre/llite/rw26.c | 34 +++++++++++++++---------------- lustre/obdclass/cl_io.c | 50 +++++++++++++++++++++++----------------------- 3 files changed, 51 insertions(+), 51 deletions(-) diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h index 2d570f2..9dccd16 100644 --- a/lustre/include/cl_object.h +++ b/lustre/include/cl_object.h @@ -2508,21 +2508,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 */ @@ -2550,7 +2550,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; struct cl_iter_dup csd_dup; spinlock_t csd_lock; @@ -2566,8 +2566,8 @@ static inline u64 cl_io_nob_aligned(u64 off, u32 nob, u32 pgsz) } 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); #ifndef HAVE_KTHREAD_USE_MM diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c index b28d9d8..8ac7df3 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, + 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); 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->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 @@ -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 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) { @@ -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->ldp_pages[i], CPT_TRANSIENT); + pv->cdp_pages[i], CPT_TRANSIENT); if (IS_ERR(page)) GOTO(out, rc = PTR_ERR(page)); @@ -432,7 +432,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); @@ -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 ll_dio_pages *pvec; + struct cl_dio_pages *pvec; count = min_t(size_t, iov_iter_count(iter), MAX_DIO_SIZE); if (rw == READ) { @@ -605,7 +605,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 4fa5f3f..81d7fec 100644 --- a/lustre/obdclass/cl_io.c +++ b/lustre/obdclass/cl_io.c @@ -1230,8 +1230,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); @@ -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 ll_dio_pages *pvec, size_t io_size) +int ll_allocate_dio_buffer(struct cl_dio_pages *pvec, size_t io_size) { size_t pg_offset; int result = 0; @@ -1373,52 +1373,52 @@ 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) GOTO(out, result = -ENOMEM); - result = obd_pool_get_pages_array(pvec->ldp_pages, pvec->ldp_count); + result = obd_pool_get_pages_array(pvec->cdp_pages, pvec->cdp_count); if (result) GOTO(out, result); 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) { - obd_pool_put_pages_array(pvec->ldp_pages, pvec->ldp_count); + obd_pool_put_pages_array(pvec->cdp_pages, pvec->cdp_count); #ifdef HAVE_DIO_ITER - kvfree(pvec->ldp_pages); + kvfree(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); @@ -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 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; @@ -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->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; @@ -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->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); out: if (mm_used) -- 1.8.3.1