#include "lov_cl_internal.h"
-/** \addtogroup lov lov @{ */
+/** \addtogroup lov
+ * @{
+ */
-static void lov_sub_enter(struct lov_io_sub *sub)
+static inline void lov_sub_enter(struct lov_io_sub *sub)
{
- ENTRY;
- if (sub->sub_reenter++ == 0) {
- sub->sub_cookie = cl_env_reenter();
- cl_env_implant(sub->sub_env, &sub->sub_refcheck2);
- }
- EXIT;
+ sub->sub_reenter++;
}
-
-static void lov_sub_exit(struct lov_io_sub *sub)
+static inline void lov_sub_exit(struct lov_io_sub *sub)
{
- ENTRY;
- if (--sub->sub_reenter == 0) {
- cl_env_unplant(sub->sub_env, &sub->sub_refcheck2);
- cl_env_reexit(sub->sub_cookie);
- }
- EXIT;
+ sub->sub_reenter--;
}
static void lov_io_sub_fini(const struct lu_env *env, struct lov_io *lio,
struct cl_io *parent = lio->lis_cl.cis_io;
switch(io->ci_type) {
- case CIT_TRUNC: {
- size_t new_size = parent->u.ci_truncate.tr_size;
-
- new_size = lov_size_to_stripe(lsm, new_size, stripe);
- io->u.ci_truncate.tr_capa = parent->u.ci_truncate.tr_capa;
- io->u.ci_truncate.tr_size = new_size;
+ case CIT_SETATTR: {
+ io->u.ci_setattr.sa_attr = parent->u.ci_setattr.sa_attr;
+ io->u.ci_setattr.sa_valid = parent->u.ci_setattr.sa_valid;
+ io->u.ci_setattr.sa_capa = parent->u.ci_setattr.sa_capa;
+ if (cl_io_is_trunc(io)) {
+ loff_t new_size = parent->u.ci_setattr.sa_attr.lvb_size;
+
+ new_size = lov_size_to_stripe(lsm, new_size, stripe);
+ io->u.ci_setattr.sa_attr.lvb_size = new_size;
+ }
break;
}
case CIT_FAULT: {
}
case CIT_READ:
case CIT_WRITE: {
- io->u.ci_rw.crw_pos = start;
- io->u.ci_rw.crw_count = end - start;
+ if (cl_io_is_append(parent)) {
+ io->u.ci_wr.wr_append = 1;
+ } else {
+ io->u.ci_rw.crw_pos = start;
+ io->u.ci_rw.crw_count = end - start;
+ }
break;
}
default:
sub->sub_io_initialized = 0;
sub->sub_borrowed = 0;
- /*
- * First sub-io. Use ->lis_single_subio and current environment, to
- * avoid dynamic allocation.
- */
- if (lio->lis_active_subios == 0) {
- sub->sub_io = &lio->lis_single_subio;
- lio->lis_single_subio_index = stripe;
- sub->sub_env = cl_env_get(&sub->sub_refcheck);
- LASSERT(sub->sub_env == env);
- } else if (lio->lis_mem_frozen) {
- LASSERT(mutex_is_locked(&ld->ld_mutex));
+ if (lio->lis_mem_frozen) {
+ LASSERT(cfs_mutex_is_locked(&ld->ld_mutex));
sub->sub_io = &ld->ld_emrg[stripe]->emrg_subio;
sub->sub_env = ld->ld_emrg[stripe]->emrg_env;
sub->sub_borrowed = 1;
cookie = cl_env_reenter();
sub->sub_env = cl_env_get(&sub->sub_refcheck);
cl_env_reexit(cookie);
-
- OBD_ALLOC_PTR(sub->sub_io);
if (IS_ERR(sub->sub_env))
result = PTR_ERR(sub->sub_env);
- else if (sub->sub_io == NULL)
- result = -ENOMEM;
+
+ if (result == 0) {
+ /*
+ * First sub-io. Use ->lis_single_subio to
+ * avoid dynamic allocation.
+ */
+ if (lio->lis_active_subios == 0) {
+ sub->sub_io = &lio->lis_single_subio;
+ lio->lis_single_subio_index = stripe;
+ } else {
+ OBD_ALLOC_PTR(sub->sub_io);
+ if (sub->sub_io == NULL)
+ result = -ENOMEM;
+ }
+ }
}
if (result == 0) {
}
break;
- case CIT_TRUNC:
- lio->lis_pos = io->u.ci_truncate.tr_size;
+ case CIT_SETATTR:
+ if (cl_io_is_trunc(io))
+ lio->lis_pos = io->u.ci_setattr.sa_attr.lvb_size;
+ else
+ lio->lis_pos = 0;
lio->lis_endpos = OBD_OBJECT_EOF;
break;
start, end);
rc = cl_io_iter_init(sub->sub_env, sub->sub_io);
lov_sub_put(sub);
- CDEBUG(D_VFSTRACE, "shrink: %i [%llu, %llu)\n",
+ CDEBUG(D_VFSTRACE, "shrink: %i ["LPU64", "LPU64")\n",
stripe, start, end);
} else
rc = PTR_ERR(sub);
if (!rc)
- list_add_tail(&sub->sub_linkage, &lio->lis_active);
+ cfs_list_add_tail(&sub->sub_linkage, &lio->lis_active);
else
break;
}
struct lov_stripe_md *lsm = lov_r0(cl2lov(ios->cis_obj))->lo_lsm;
loff_t start = io->u.ci_rw.crw_pos;
loff_t next;
- int ssize = lsm->lsm_stripe_size;
+ unsigned long ssize = lsm->lsm_stripe_size;
LASSERT(io->ci_type == CIT_READ || io->ci_type == CIT_WRITE);
ENTRY;
next) - io->u.ci_rw.crw_pos;
lio->lis_pos = io->u.ci_rw.crw_pos;
lio->lis_endpos = io->u.ci_rw.crw_pos + io->u.ci_rw.crw_count;
- CDEBUG(D_VFSTRACE, "stripe: %llu chunk: [%llu, %llu) %llu\n",
+ CDEBUG(D_VFSTRACE, "stripe: "LPU64" chunk: ["LPU64", "LPU64") "LPU64"\n",
(__u64)start, lio->lis_pos, lio->lis_endpos,
(__u64)lio->lis_io_endpos);
}
int rc = 0;
ENTRY;
- list_for_each_entry(sub, &lio->lis_active, sub_linkage) {
+ cfs_list_for_each_entry(sub, &lio->lis_active, sub_linkage) {
lov_sub_enter(sub);
rc = iofunc(sub->sub_env, sub->sub_io);
lov_sub_exit(sub);
ENTRY;
rc = lov_io_call(env, lio, lov_io_iter_fini_wrapper);
LASSERT(rc == 0);
- while (!list_empty(&lio->lis_active))
- list_del_init(lio->lis_active.next);
+ while (!cfs_list_empty(&lio->lis_active))
+ cfs_list_del_init(lio->lis_active.next);
EXIT;
}
* In order to not make things worse, even don't try to
* allocate the memory with __GFP_NOWARN. -jay
*/
- mutex_lock(&ld->ld_mutex);
+ cfs_mutex_lock(&ld->ld_mutex);
lio->lis_mem_frozen = 1;
}
struct lov_io_sub *sub;
struct cl_page_list *sub_qin = QIN(stripe);
- if (list_empty(&sub_qin->pl_pages))
+ if (cfs_list_empty(&sub_qin->pl_pages))
continue;
cl_page_list_splice(sub_qin, &cl2q->c2_qin);
for (stripe = 0; stripe < lio->lis_nr_subios; stripe++) {
struct cl_page_list *sub_qin = QIN(stripe);
- if (list_empty(&sub_qin->pl_pages))
+ if (cfs_list_empty(&sub_qin->pl_pages))
continue;
cl_page_list_splice(sub_qin, qin);
lov_io_sub_fini(env, lio, &lio->lis_subs[i]);
}
lio->lis_mem_frozen = 0;
- mutex_unlock(&ld->ld_mutex);
+ cfs_mutex_unlock(&ld->ld_mutex);
}
RETURN(rc);
.cio_start = lov_io_start,
.cio_end = lov_io_end
},
- [CIT_TRUNC] = {
+ [CIT_SETATTR] = {
.cio_fini = lov_io_fini,
.cio_iter_init = lov_io_iter_init,
.cio_iter_fini = lov_io_iter_fini,
.cio_start = LOV_EMPTY_IMPOSSIBLE,
.cio_end = LOV_EMPTY_IMPOSSIBLE
},
- [CIT_TRUNC] = {
+ [CIT_SETATTR] = {
.cio_fini = lov_empty_io_fini,
.cio_iter_init = LOV_EMPTY_IMPOSSIBLE,
.cio_lock = LOV_EMPTY_IMPOSSIBLE,
result = 0;
break;
case CIT_WRITE:
- case CIT_TRUNC:
+ case CIT_SETATTR:
result = -EBADF;
break;
case CIT_FAULT:
git://git.whamcloud.com / fs / lustre-release.git / blobdiff