ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
int rw, struct inode *inode,
struct ll_dio_pages *pv)
{
struct cl_page *clp;
struct cl_2queue *queue;
struct cl_object *obj = io->ci_obj;
int i;
ssize_t rc = 0;
loff_t file_offset = pv->ldp_start_offset;
size_t size = pv->ldp_size;
int page_count = pv->ldp_nr;
struct page **pages = pv->ldp_pages;
size_t page_size = cl_page_size(obj);
bool do_io;
int io_pages = 0;
ENTRY;
queue = &io->ci_queue;
cl_2queue_init(queue);
for (i = 0; i < page_count; i++) {
if (pv->ldp_offsets)
file_offset = pv->ldp_offsets[i];
LASSERT(!(file_offset & (page_size - 1)));
clp = cl_page_find(env, obj, cl_index(obj, file_offset),
pv->ldp_pages[i], CPT_TRANSIENT);
if (IS_ERR(clp)) {
rc = PTR_ERR(clp);
break;
}
rc = cl_page_own(env, io, clp);
if (rc) {
LASSERT(clp->cp_state == CPS_FREEING);
cl_page_put(env, clp);
break;
}
do_io = true;
/* check the page type: if the page is a host page, then do
* write directly */
if (clp->cp_type == CPT_CACHEABLE) {
struct page *vmpage = cl_page_vmpage(clp);
struct page *src_page;
struct page *dst_page;
void *src;
void *dst;
src_page = (rw == WRITE) ? pages[i] : vmpage;
dst_page = (rw == WRITE) ? vmpage : pages[i];
src = ll_kmap_atomic(src_page, KM_USER0);
dst = ll_kmap_atomic(dst_page, KM_USER1);
memcpy(dst, src, min(page_size, size));
ll_kunmap_atomic(dst, KM_USER1);
ll_kunmap_atomic(src, KM_USER0);
/* make sure page will be added to the transfer by
* cl_io_submit()->...->vvp_page_prep_write(). */
if (rw == WRITE)
set_page_dirty(vmpage);
if (rw == READ) {
/* do not issue the page for read, since it
* may reread a ra page which has NOT uptodate
* bit set. */
cl_page_disown(env, io, clp);
do_io = false;
}
}
if (likely(do_io)) {
cl_2queue_add(queue, clp);
/*
* Set page clip to tell transfer formation engine
* that page has to be sent even if it is beyond KMS.
*/
cl_page_clip(env, clp, 0, min(size, page_size));
++io_pages;
}
/* drop the reference count for cl_page_find */
cl_page_put(env, clp);
size -= page_size;
file_offset += page_size;
}
if (rc == 0 && io_pages) {
rc = cl_io_submit_sync(env, io,
rw == READ ? CRT_READ : CRT_WRITE,
queue, 0);
}
if (rc == 0)
rc = pv->ldp_size;
cl_2queue_discard(env, io, queue);
cl_2queue_disown(env, io, queue);
cl_2queue_fini(env, queue);
RETURN(rc);
}
static int llu_queue_pio(const struct lu_env *env, struct cl_io *io,
struct llu_io_group *group,
char *buf, size_t count, loff_t pos)
{
struct cl_object *obj = io->ci_obj;
struct inode *inode = ccc_object_inode(obj);
struct intnl_stat *st = llu_i2stat(inode);
struct obd_export *exp = llu_i2obdexp(inode);
struct page *page;
int rc = 0, ret_bytes = 0;
struct cl_page *clp;
struct cl_2queue *queue;
ENTRY;
if (!exp)
RETURN(-EINVAL);
queue = &io->ci_queue;
cl_2queue_init(queue);
/* prepare the pages array */
do {
unsigned long index, offset, bytes;
offset = (pos & ~CFS_PAGE_MASK);
index = pos >> PAGE_CACHE_SHIFT;
bytes = PAGE_CACHE_SIZE - offset;
if (bytes > count)
bytes = count;
/* prevent read beyond file range */
if (/* local_lock && */
io->ci_type == CIT_READ && pos + bytes >= st->st_size) {
if (pos >= st->st_size)
break;
bytes = st->st_size - pos;
}
/* prepare page for this index */
page = llu_get_user_page(index, buf - offset, offset, bytes);
if (!page) {
rc = -ENOMEM;
break;
}
clp = cl_page_find(env, obj,
cl_index(obj, pos),
page, CPT_TRANSIENT);
if (IS_ERR(clp)) {
rc = PTR_ERR(clp);
break;
}
rc = cl_page_own(env, io, clp);
if (rc) {
LASSERT(clp->cp_state == CPS_FREEING);
cl_page_put(env, clp);
break;
}
cl_2queue_add(queue, clp);
/* drop the reference count for cl_page_find, so that the page
* will be freed in cl_2queue_fini. */
cl_page_put(env, clp);
cl_page_clip(env, clp, offset, offset+bytes);
count -= bytes;
pos += bytes;
buf += bytes;
group->lig_rwcount += bytes;
ret_bytes += bytes;
page++;
} while (count);
if (rc == 0) {
enum cl_req_type iot;
iot = io->ci_type == CIT_READ ? CRT_READ : CRT_WRITE;
rc = cl_io_submit_sync(env, io, iot, queue, 0);
}
group->lig_rc = rc;
cl_2queue_discard(env, io, queue);
cl_2queue_disown(env, io, queue);
cl_2queue_fini(env, queue);
RETURN(ret_bytes);
}
