#include <linux/kthread.h>
#include "ofd_internal.h"
+#include <lustre_nodemap.h>
struct ofd_inconsistency_item {
struct list_head oii_list;
struct ofd_object *oii_obj;
- struct lu_fid oii_pfid;
+ struct filter_fid oii_ff;
};
/**
* \param[in] env execution environment
* \param[in] ofd OFD device
* \param[in] oii object-related local data
- * \param[in] lr LFSCK request data
+ * \param[in] lrl LFSCK request data
*/
static void ofd_inconsistency_verify_one(const struct lu_env *env,
struct ofd_device *ofd,
struct ofd_inconsistency_item *oii,
- struct lfsck_request *lr)
+ struct lfsck_req_local *lrl)
{
- struct ofd_object *fo = oii->oii_obj;
- struct lu_fid *pfid = &fo->ofo_pfid;
- int rc;
+ struct ofd_object *fo = oii->oii_obj;
+ struct filter_fid *client_ff = &oii->oii_ff;
+ struct filter_fid *local_ff = &fo->ofo_ff;
+ int rc;
LASSERT(fo->ofo_pfid_checking);
LASSERT(!fo->ofo_pfid_verified);
- lr->lr_fid = fo->ofo_header.loh_fid; /* OST-object itself FID. */
- lr->lr_fid2 = oii->oii_pfid; /* client given PFID. */
- lr->lr_fid3 = *pfid; /* OST local stored PFID. */
+ lrl->lrl_fid = fo->ofo_header.loh_fid; /* OST-object itself FID. */
+ lrl->lrl_ff_client = *client_ff; /* client given PFID. */
+ lrl->lrl_ff_local = *local_ff; /* OST local stored PFID. */
- rc = lfsck_in_notify(env, ofd->ofd_osd, lr, NULL);
+ rc = lfsck_in_notify_local(env, ofd->ofd_osd, lrl, NULL);
ofd_write_lock(env, fo);
- switch (lr->lr_status) {
+ switch (lrl->lrl_status) {
case LPVS_INIT:
LASSERT(rc <= 0);
"PFID xattr for "DFID", the client given PFID "
DFID", OST local stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
- PFID(&oii->oii_pfid), PFID(pfid), rc);
+ PFID(&client_ff->ff_parent),
+ PFID(&local_ff->ff_parent), rc);
else
fo->ofo_pfid_verified = 1;
break;
"PFID for "DFID", the client given PFID "DFID
", local stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
- PFID(&oii->oii_pfid), PFID(pfid), rc);
+ PFID(&client_ff->ff_parent),
+ PFID(&local_ff->ff_parent), rc);
else
CDEBUG(D_LFSCK, "%s: both the client given PFID and "
"the OST local stored PFID are stale for the "
"OST-object "DFID", client given PFID is "DFID
", local stored PFID is "DFID"\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
- PFID(&oii->oii_pfid), PFID(pfid));
+ PFID(&client_ff->ff_parent),
+ PFID(&local_ff->ff_parent));
break;
case LPVS_INCONSISTENT_TOFIX:
ofd->ofd_inconsistency_self_detected++;
"for "DFID", with the client given PFID "DFID
", the old stored PFID "DFID"\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
- PFID(&oii->oii_pfid), PFID(pfid));
+ PFID(&client_ff->ff_parent),
+ PFID(&local_ff->ff_parent));
} else if (rc < 0) {
CDEBUG(D_LFSCK, "%s: fail to fix the OST PFID xattr "
"for "DFID", client given PFID "DFID", local "
"stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
- PFID(&oii->oii_pfid), PFID(pfid), rc);
+ PFID(&client_ff->ff_parent),
+ PFID(&local_ff->ff_parent), rc);
}
- *pfid = oii->oii_pfid;
+ local_ff->ff_parent = client_ff->ff_parent;
fo->ofo_pfid_verified = 1;
break;
default:
fo->ofo_pfid_checking = 0;
ofd_write_unlock(env, fo);
- lu_object_put(env, &fo->ofo_obj.do_lu);
+ ofd_object_put(env, fo);
OBD_FREE_PTR(oii);
}
*/
static int ofd_inconsistency_verification_main(void *args)
{
- struct lu_env env;
- struct ofd_device *ofd = args;
- struct ptlrpc_thread *thread = &ofd->ofd_inconsistency_thread;
+ struct lu_env env;
+ struct ofd_device *ofd = args;
+ struct ptlrpc_thread *thread = &ofd->ofd_inconsistency_thread;
struct ofd_inconsistency_item *oii;
- struct lfsck_request *lr = NULL;
- struct l_wait_info lwi = { 0 };
- int rc;
+ struct lfsck_req_local *lrl = NULL;
+ struct l_wait_info lwi = { 0 };
+ int rc;
ENTRY;
rc = lu_env_init(&env, LCT_DT_THREAD);
spin_lock(&ofd->ofd_inconsistency_lock);
- thread_set_flags(thread, rc != 0 ? SVC_STOPPED : SVC_RUNNING);
+ thread_set_flags(thread, rc ? SVC_STOPPED : SVC_RUNNING);
wake_up_all(&thread->t_ctl_waitq);
spin_unlock(&ofd->ofd_inconsistency_lock);
- if (rc != 0)
+ if (rc)
RETURN(rc);
- OBD_ALLOC_PTR(lr);
- if (unlikely(lr == NULL))
+ OBD_ALLOC_PTR(lrl);
+ if (unlikely(!lrl))
GOTO(out_unlocked, rc = -ENOMEM);
- lr->lr_event = LE_PAIRS_VERIFY;
- lr->lr_active = LFSCK_TYPE_LAYOUT;
+ lrl->lrl_event = LEL_PAIRS_VERIFY_LOCAL;
+ lrl->lrl_active = LFSCK_TYPE_LAYOUT;
spin_lock(&ofd->ofd_inconsistency_lock);
while (1) {
oii_list);
list_del_init(&oii->oii_list);
spin_unlock(&ofd->ofd_inconsistency_lock);
- ofd_inconsistency_verify_one(&env, ofd, oii, lr);
+ ofd_inconsistency_verify_one(&env, ofd, oii, lrl);
spin_lock(&ofd->ofd_inconsistency_lock);
}
fo->ofo_pfid_checking = 0;
ofd_write_unlock(&env, fo);
- lu_object_put(&env, &fo->ofo_obj.do_lu);
+ ofd_object_put(&env, fo);
OBD_FREE_PTR(oii);
spin_lock(&ofd->ofd_inconsistency_lock);
}
- OBD_FREE_PTR(lr);
+ OBD_FREE_PTR(lrl);
GOTO(out, rc = 0);
static void ofd_add_inconsistency_item(const struct lu_env *env,
struct ofd_object *fo, struct obdo *oa)
{
- struct ofd_device *ofd = ofd_obj2dev(fo);
- struct ofd_inconsistency_item *oii;
- bool wakeup = false;
+ struct ofd_device *ofd = ofd_obj2dev(fo);
+ struct ofd_inconsistency_item *oii;
+ struct filter_fid *ff;
+ bool wakeup = false;
OBD_ALLOC_PTR(oii);
if (oii == NULL)
INIT_LIST_HEAD(&oii->oii_list);
lu_object_get(&fo->ofo_obj.do_lu);
oii->oii_obj = fo;
- oii->oii_pfid.f_seq = oa->o_parent_seq;
- oii->oii_pfid.f_oid = oa->o_parent_oid;
- oii->oii_pfid.f_stripe_idx = oa->o_stripe_idx;
+ ff = &oii->oii_ff;
+ ff->ff_parent.f_seq = oa->o_parent_seq;
+ ff->ff_parent.f_oid = oa->o_parent_oid;
+ ff->ff_parent.f_stripe_idx = oa->o_stripe_idx;
+ ff->ff_layout = oa->o_layout;
spin_lock(&ofd->ofd_inconsistency_lock);
if (fo->ofo_pfid_checking || fo->ofo_pfid_verified) {
int ofd_verify_ff(const struct lu_env *env, struct ofd_object *fo,
struct obdo *oa)
{
- struct lu_fid *pfid = &fo->ofo_pfid;
- int rc = 0;
+ struct lu_fid *pfid = &fo->ofo_ff.ff_parent;
+ int rc = 0;
ENTRY;
if (fid_is_sane(pfid)) {
struct niobuf_remote *rnb, int *nr_local,
struct niobuf_local *lnb, char *jobid)
{
- struct ofd_object *fo;
- int i, j, rc, tot_bytes = 0;
+ struct ofd_object *fo;
+ int i, j, rc, tot_bytes = 0;
+ enum dt_bufs_type dbt = DT_BUFS_TYPE_READ;
ENTRY;
LASSERT(env != NULL);
GOTO(unlock, rc);
}
- *nr_local = 0;
- for (i = 0, j = 0; i < niocount; i++) {
+ if (ptlrpc_connection_is_local(exp->exp_connection))
+ dbt |= DT_BUFS_TYPE_LOCAL;
+
+ for (*nr_local = 0, i = 0, j = 0; i < niocount; i++) {
rc = dt_bufs_get(env, ofd_object_child(fo), rnb + i,
- lnb + j, 0);
+ lnb + j, dbt);
if (unlikely(rc < 0))
GOTO(buf_put, rc);
LASSERT(rc <= PTLRPC_MAX_BRW_PAGES);
struct niobuf_remote *rnb, int *nr_local,
struct niobuf_local *lnb, char *jobid)
{
- struct ofd_object *fo;
- int i, j, k, rc = 0, tot_bytes = 0;
+ struct ofd_object *fo;
+ int i, j, k, rc = 0, tot_bytes = 0;
+ enum dt_bufs_type dbt = DT_BUFS_TYPE_WRITE;
ENTRY;
LASSERT(env != NULL);
/* Process incoming grant info, set OBD_BRW_GRANTED flag and grant some
* space back if possible */
- ofd_grant_prepare_write(env, exp, oa, rnb, obj->ioo_bufcnt);
+ tgt_grant_prepare_write(env, exp, oa, rnb, obj->ioo_bufcnt);
+
+ if (ptlrpc_connection_is_local(exp->exp_connection))
+ dbt |= DT_BUFS_TYPE_LOCAL;
/* parse remote buffers to local buffers and prepare the latter */
- *nr_local = 0;
- for (i = 0, j = 0; i < obj->ioo_bufcnt; i++) {
+ for (*nr_local = 0, i = 0, j = 0; i < obj->ioo_bufcnt; i++) {
rc = dt_bufs_get(env, ofd_object_child(fo),
- rnb + i, lnb + j, 1);
+ rnb + i, lnb + j, dbt);
if (unlikely(rc < 0))
GOTO(err, rc);
LASSERT(rc <= PTLRPC_MAX_BRW_PAGES);
dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local);
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
- /* ofd_grant_prepare_write() was called, so we must commit */
- ofd_grant_commit(exp, oa->o_grant_used, rc);
+ /* tgt_grant_prepare_write() was called, so we must commit */
+ tgt_grant_commit(exp, oa->o_grant_used, rc);
out:
/* let's still process incoming grant information packed in the oa,
* but without enforcing grant since we won't proceed with the write.
* Just like a read request actually. */
- ofd_grant_prepare_read(env, exp, oa);
+ tgt_grant_prepare_read(env, exp, oa);
return rc;
}
rc = ofd_preprw_write(env, exp, ofd, fid, &info->fti_attr, oa,
objcount, obj, rnb, nr_local, lnb, jobid);
} else if (cmd == OBD_BRW_READ) {
- ofd_grant_prepare_read(env, exp, oa);
+ tgt_grant_prepare_read(env, exp, oa);
rc = ofd_preprw_read(env, exp, ofd, fid, &info->fti_attr, oa,
obj->ioo_bufcnt, rnb, nr_local, lnb,
jobid);
dt_obj = ofd_object_child(ofd_obj);
LASSERT(dt_obj != NULL);
- la->la_valid &= LA_UID | LA_GID;
+ la->la_valid &= LA_UID | LA_GID | LA_PROJID;
- rc = ofd_attr_handle_ugid(env, ofd_obj, la, 0 /* !is_setattr */);
+ rc = ofd_attr_handle_id(env, ofd_obj, la, 0 /* !is_setattr */);
if (rc != 0)
GOTO(out, rc);
if (ff_needed) {
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR1))
ff->ff_parent.f_oid = cpu_to_le32(1UL << 31);
- if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR2))
- ff->ff_parent.f_oid =
- cpu_to_le32(le32_to_cpu(ff->ff_parent.f_oid) - 1);
+ else if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR2))
+ le32_add_cpu(&ff->ff_parent.f_oid, -1);
info->fti_buf.lb_buf = ff;
info->fti_buf.lb_len = sizeof(*ff);
if (rc)
GOTO(out_tx, rc);
- /* set uid/gid */
+ /* set uid/gid/projid */
if (la->la_valid) {
rc = dt_attr_set(env, dt_obj, la, th);
if (rc)
rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID,
0, th);
- if (rc == 0) {
- ofd_obj->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq);
- ofd_obj->ofo_pfid.f_oid = le32_to_cpu(ff->ff_parent.f_oid);
- /* Currently, the filter_fid::ff_parent::f_ver is not
- * the real parent MDT-object's FID::f_ver, instead it
- * is the OST-object index in its parent MDT-object's
- * layout EA. */
- ofd_obj->ofo_pfid.f_stripe_idx =
- le32_to_cpu(ff->ff_parent.f_stripe_idx);
- }
+ if (!rc)
+ filter_fid_le_to_cpu(&ofd_obj->ofo_ff, ff, sizeof(*ff));
}
GOTO(out_tx, rc);
}
if (rc == 0 && granted > 0) {
- if (ofd_grant_commit_cb_add(th, exp, granted) == 0)
+ if (tgt_grant_commit_cb_add(th, exp, granted) == 0)
granted = 0;
}
/* second put is pair to object_get in ofd_preprw_write */
ofd_object_put(env, fo);
if (granted > 0)
- ofd_grant_commit(exp, granted, old_rc);
+ tgt_grant_commit(exp, granted, old_rc);
RETURN(rc);
}
LASSERT(npages > 0);
if (cmd == OBD_BRW_WRITE) {
+ struct lu_nodemap *nodemap;
+
/* Don't update timestamps if this write is older than a
* setattr which modifies the timestamps. b=10150 */
* to be changed to ofd_fmd_get() to create the fmd if it
* doesn't already exist so we can store the reservation handle
* there. */
- valid = OBD_MD_FLUID | OBD_MD_FLGID;
+ valid = OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLPROJID;
fmd = ofd_fmd_find(exp, fid);
if (!fmd || fmd->fmd_mactime_xid < info->fti_xid)
valid |= OBD_MD_FLATIME | OBD_MD_FLMTIME |
oa->o_grant_used, old_rc);
if (rc == 0)
obdo_from_la(oa, &info->fti_attr,
- OFD_VALID_FLAGS | LA_GID | LA_UID);
+ OFD_VALID_FLAGS | LA_GID | LA_UID |
+ LA_PROJID);
else
- obdo_from_la(oa, &info->fti_attr, LA_GID | LA_UID);
+ obdo_from_la(oa, &info->fti_attr, LA_GID | LA_UID |
+ LA_PROJID);
/* don't report overquota flag if we failed before reaching
* commit */
else
oa->o_flags = OBD_FL_NO_GRPQUOTA;
}
+ if (lnb[0].lnb_flags & OBD_BRW_OVER_PRJQUOTA) {
+ if (oa->o_valid & OBD_MD_FLFLAGS)
+ oa->o_flags |= OBD_FL_NO_PRJQUOTA;
+ else
+ oa->o_flags = OBD_FL_NO_PRJQUOTA;
+ }
oa->o_valid |= OBD_MD_FLFLAGS;
- oa->o_valid |= OBD_MD_FLUSRQUOTA | OBD_MD_FLGRPQUOTA;
+ oa->o_valid |= OBD_MD_FLALLQUOTA;
+ }
+
+ /* Convert back to client IDs. LU-9671.
+ * nodemap_get_from_exp() may fail due to nodemap deactivated,
+ * server ID will be returned back to client in that case. */
+ nodemap = nodemap_get_from_exp(exp);
+ if (nodemap != NULL && !IS_ERR(nodemap)) {
+ oa->o_uid = nodemap_map_id(nodemap, NODEMAP_UID,
+ NODEMAP_FS_TO_CLIENT,
+ oa->o_uid);
+ oa->o_gid = nodemap_map_id(nodemap, NODEMAP_GID,
+ NODEMAP_FS_TO_CLIENT,
+ oa->o_gid);
+ nodemap_putref(nodemap);
}
} else if (cmd == OBD_BRW_READ) {
struct ldlm_namespace *ns = ofd->ofd_namespace;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff