* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
struct cl_object *obj, struct cl_io *io);
int (*llo_getattr)(const struct lu_env *env, struct cl_object *obj,
struct cl_attr *attr);
- int (*llo_find_cbdata)(const struct lu_env *env, struct cl_object *obj,
- ldlm_iterator_t iter, void *data);
};
static int lov_layout_wait(const struct lu_env *env, struct lov_object *lov);
}
LU_OBJECT_DEBUG(mask, env, &stripe->co_lu,
- "stripe %d is already owned.\n", idx);
- LU_OBJECT_DEBUG(mask, env, old_obj, "owned.\n");
+ "stripe %d is already owned.", idx);
+ LU_OBJECT_DEBUG(mask, env, old_obj, "owned.");
LU_OBJECT_HEADER(mask, env, lov2lu(lov), "try to own.\n");
cl_object_put(env, stripe);
}
if (result != 0)
GOTO(out, result);
+ if (dev->ld_target[ost_idx] == NULL) {
+ CERROR("%s: OST %04x is not initialized\n",
+ lov2obd(dev->ld_lov)->obd_name, ost_idx);
+ GOTO(out, result = -EIO);
+ }
+
subdev = lovsub2cl_dev(dev->ld_target[ost_idx]);
subconf->u.coc_oinfo = oinfo;
LASSERTF(subdev != NULL, "not init ost %d\n", ost_idx);
RETURN(result);
}
-static int lov_find_cbdata_empty(const struct lu_env *env,
- struct cl_object *obj, ldlm_iterator_t iter,
- void *data)
-{
- return 0;
-}
-
-static int lov_find_cbdata_raid0(const struct lu_env *env,
- struct cl_object *obj, ldlm_iterator_t iter,
- void *data)
-{
- struct lov_object *lov = cl2lov(obj);
- struct lov_layout_raid0 *r0 = lov_r0(lov);
- struct cl_object *subobj;
- int i;
- int rc = 0;
-
- for (i = 0; i < r0->lo_nr; ++i) {
- if (r0->lo_sub[i] == NULL)
- continue;
-
- subobj = lovsub2cl(r0->lo_sub[i]);
-
- rc = cl_object_find_cbdata(env, subobj, iter, data);
- if (rc != 0)
- break;
- }
-
- return rc;
-}
-
const static struct lov_layout_operations lov_dispatch[] = {
[LLT_EMPTY] = {
.llo_init = lov_init_empty,
.llo_lock_init = lov_lock_init_empty,
.llo_io_init = lov_io_init_empty,
.llo_getattr = lov_attr_get_empty,
- .llo_find_cbdata = lov_find_cbdata_empty
},
[LLT_RAID0] = {
.llo_init = lov_init_raid0,
.llo_lock_init = lov_lock_init_raid0,
.llo_io_init = lov_io_init_raid0,
.llo_getattr = lov_attr_get_raid0,
- .llo_find_cbdata = lov_find_cbdata_raid0
},
[LLT_RELEASED] = {
.llo_init = lov_init_released,
.llo_lock_init = lov_lock_init_empty,
.llo_io_init = lov_io_init_released,
.llo_getattr = lov_attr_get_empty,
- .llo_find_cbdata = lov_find_cbdata_empty
}
};
static inline void lov_conf_freeze(struct lov_object *lov)
{
+ CDEBUG(D_INODE, "To take share lov(%p) owner %p/%p\n",
+ lov, lov->lo_owner, current);
if (lov->lo_owner != current)
down_read(&lov->lo_type_guard);
}
static inline void lov_conf_thaw(struct lov_object *lov)
{
+ CDEBUG(D_INODE, "To release share lov(%p) owner %p/%p\n",
+ lov, lov->lo_owner, current);
if (lov->lo_owner != current)
up_read(&lov->lo_type_guard);
}
down_write(&lov->lo_type_guard);
LASSERT(lov->lo_owner == NULL);
lov->lo_owner = current;
+ CDEBUG(D_INODE, "Took exclusive lov(%p) owner %p\n",
+ lov, lov->lo_owner);
}
static void lov_conf_unlock(struct lov_object *lov)
{
+ CDEBUG(D_INODE, "To release exclusive lov(%p) owner %p\n",
+ lov, lov->lo_owner);
lov->lo_owner = NULL;
up_write(&lov->lo_type_guard);
}
union lov_layout_state *state = &lov->u;
const struct lov_layout_operations *old_ops;
const struct lov_layout_operations *new_ops;
- void *cookie;
+ struct lov_device *lov_dev = lov_object_dev(lov);
struct lu_env *env;
- int refcheck;
+ __u16 refcheck;
int rc;
ENTRY;
LASSERT(0 <= lov->lo_type && lov->lo_type < ARRAY_SIZE(lov_dispatch));
- cookie = cl_env_reenter();
env = cl_env_get(&refcheck);
- if (IS_ERR(env)) {
- cl_env_reexit(cookie);
+ if (IS_ERR(env))
RETURN(PTR_ERR(env));
- }
LASSERT(0 <= llt && llt < ARRAY_SIZE(lov_dispatch));
LASSERT(atomic_read(&lov->lo_active_ios) == 0);
+ CDEBUG(D_INODE, DFID "Apply new layout lov %p, type %d\n",
+ PFID(lu_object_fid(lov2lu(lov))), lov, llt);
+
lov->lo_type = LLT_EMPTY;
/* page bufsize fixup */
cl_object_header(&lov->lo_cl)->coh_page_bufsize -=
lov_page_slice_fixup(lov, NULL);
- rc = new_ops->llo_init(env, lov_object_dev(lov), lov, lsm, conf, state);
+ rc = new_ops->llo_init(env, lov_dev, lov, lsm, conf, state);
if (rc != 0) {
+ struct obd_device *obd = lov2obd(lov_dev->ld_lov);
+
+ CERROR("%s: cannot apply new layout on "DFID" : rc = %d\n",
+ obd->obd_name, PFID(lu_object_fid(lov2lu(lov))), rc);
new_ops->llo_delete(env, lov, state);
new_ops->llo_fini(env, lov, state);
/* this file becomes an EMPTY file. */
out:
cl_env_put(env, &refcheck);
- cl_env_reexit(cookie);
-
RETURN(rc);
}
init_waitqueue_head(&lov->lo_waitq);
cl_object_page_init(lu2cl(obj), sizeof(struct lov_page));
+ lov->lo_type = LLT_EMPTY;
if (cconf->u.coc_layout.lb_buf != NULL) {
lsm = lov_unpackmd(dev->ld_lov,
cconf->u.coc_layout.lb_buf,
struct cl_io *io)
{
CL_IO_SLICE_CLEAN(lov_env_io(env), lis_cl);
+
+ CDEBUG(D_INODE, DFID "io %p type %d ignore/verify layout %d/%d\n",
+ PFID(lu_object_fid(&obj->co_lu)), io, io->ci_type,
+ io->ci_ignore_layout, io->ci_verify_layout);
+
return LOV_2DISPATCH_MAYLOCK(cl2lov(obj), llo_io_init,
!io->ci_ignore_layout, env, obj, io);
}
*/
if (lsm->lsm_stripe_count > 1 && !(fiemap->fm_flags &
FIEMAP_FLAG_DEVICE_ORDER))
- GOTO(out, rc = -ENOTSUPP);
+ GOTO(out_lsm, rc = -ENOTSUPP);
if (lsm_is_released(lsm)) {
if (fiemap->fm_start < fmkey->lfik_oa.o_size) {
fiemap->fm_extents[0].fe_flags |=
FIEMAP_EXTENT_UNKNOWN | FIEMAP_EXTENT_LAST;
}
- GOTO(out, rc = 0);
+ GOTO(out_lsm, rc = 0);
}
if (fiemap_count_to_size(fiemap->fm_extent_count) < buffer_size)
OBD_ALLOC_LARGE(fm_local, buffer_size);
if (fm_local == NULL)
- GOTO(out, rc = -ENOMEM);
+ GOTO(out_lsm, rc = -ENOMEM);
lcl_fm_ext = &fm_local->fm_extents[0];
count_local = fiemap_size_to_count(buffer_size);
fm_end_offset = fiemap_calc_fm_end_offset(fiemap, lsm, fm_start, fm_end,
&start_stripe);
if (fm_end_offset == -EINVAL)
- GOTO(out, rc = -EINVAL);
+ GOTO(out_fm_local, rc = -EINVAL);
/**
* Requested extent count exceeds the fiemap buffer size, shrink our
continue;
if (lov_oinfo_is_dummy(lsm->lsm_oinfo[cur_stripe]))
- GOTO(out, rc = -EIO);
+ GOTO(out_fm_local, rc = -EIO);
/* If this is a continuation FIEMAP call and we are on
* starting stripe then lun_start needs to be set to
subobj = lov_find_subobj(env, cl2lov(obj), lsm,
cur_stripe);
if (IS_ERR(subobj))
- GOTO(out, rc = PTR_ERR(subobj));
+ GOTO(out_fm_local, rc = PTR_ERR(subobj));
/* If the output buffer is very large and the objects have many
* extents we may need to loop on a single OST repeatedly */
ost_eof = false;
obj_put:
if (subobj != NULL)
cl_object_put(env, subobj);
-out:
- if (fm_local != NULL)
- OBD_FREE_LARGE(fm_local, buffer_size);
+out_fm_local:
+ OBD_FREE_LARGE(fm_local, buffer_size);
+out_lsm:
lov_lsm_put(lsm);
return rc;
return maxbytes;
}
-static int lov_object_find_cbdata(const struct lu_env *env,
- struct cl_object *obj, ldlm_iterator_t iter,
- void *data)
-{
- int rc;
- ENTRY;
-
- /* call cl_object_find_cbdata for sub obj */
- rc = LOV_2DISPATCH_NOLOCK(cl2lov(obj), llo_find_cbdata,
- env, obj, iter, data);
- RETURN(rc);
-}
-
static const struct cl_object_operations lov_ops = {
.coo_page_init = lov_page_init,
.coo_lock_init = lov_lock_init,
.coo_getstripe = lov_object_getstripe,
.coo_layout_get = lov_object_layout_get,
.coo_maxbytes = lov_object_maxbytes,
- .coo_find_cbdata = lov_object_find_cbdata,
.coo_fiemap = lov_object_fiemap,
};
git://git.whamcloud.com / fs / lustre-release.git / blobdiff