};
/** 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 */
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;
}
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
#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);
}
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
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) {
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));
/* 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);
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) {
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);
/* 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);
* 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;
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);
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;
* 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;
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)
git://git.whamcloud.com / fs / lustre-release.git / commitdiff