*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/mdd/mdd_object.c
*
enum changelog_rec_type type,
enum changelog_rec_flags clf_flags,
const struct lu_fid *fid,
+ const struct lu_fid *pfid,
const char *xattr_name,
struct thandle *handle);
rc2 = mdd_changelog_data_store_by_fid(env, mdd, CL_GETXATTR, 0,
mdd_object_fid(mdd_obj),
- name, handle);
+ NULL, name, handle);
stop:
rc2 = mdd_trans_stop(env, mdd, rc2, handle);
RETURN(0);
if (is_project_state_change(oattr, la)) {
- if (!md_capable(uc, CFS_CAP_SYS_RESOURCE) &&
+ if (!md_capable(uc, CAP_SYS_RESOURCE) &&
!lustre_in_group_p(uc, ma->ma_enable_chprojid_gid) &&
!(ma->ma_enable_chprojid_gid == -1 &&
mdd_permission_internal(env, obj, oattr, MAY_WRITE)))
(LUSTRE_IMMUTABLE_FL | LUSTRE_APPEND_FL);
if ((uc->uc_fsuid != oattr->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
/* The IMMUTABLE and APPEND_ONLY flags can
* only be changed by the relevant capability. */
if ((oldflags ^ newflags) &&
- !md_capable(uc, CFS_CAP_LINUX_IMMUTABLE))
+ !md_capable(uc, CAP_LINUX_IMMUTABLE))
RETURN(-EPERM);
- if (!S_ISDIR(oattr->la_mode))
+ if (!S_ISDIR(oattr->la_mode)) {
la->la_flags &= ~(LUSTRE_DIRSYNC_FL | LUSTRE_TOPDIR_FL);
+ } else if (la->la_flags & LUSTRE_ENCRYPT_FL) {
+ /* when trying to add encryption flag on dir,
+ * make sure it is empty
+ */
+ rc = mdd_dir_is_empty(env, obj);
+ if (rc)
+ RETURN(rc);
+ rc = 0;
+ }
}
if (oattr->la_flags & (LUSTRE_IMMUTABLE_FL | LUSTRE_APPEND_FL) &&
if ((la->la_valid & (LA_MTIME | LA_ATIME | LA_CTIME)) &&
!(la->la_valid & ~(LA_MTIME | LA_ATIME | LA_CTIME))) {
if ((uc->uc_fsuid != oattr->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER)) {
+ !md_capable(uc, CAP_FOWNER)) {
rc = mdd_permission_internal(env, obj, oattr,
MAY_WRITE);
if (rc)
if (la->la_valid & LA_MODE) {
if (!(flags & MDS_PERM_BYPASS) &&
(uc->uc_fsuid != oattr->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
if (la->la_mode == (umode_t) -1)
/* Also check the setgid bit! */
if (!lustre_in_group_p(uc, (la->la_valid & LA_GID) ?
la->la_gid : oattr->la_gid) &&
- !md_capable(uc, CFS_CAP_FSETID))
+ !md_capable(uc, CAP_FSETID))
la->la_mode &= ~S_ISGID;
} else {
la->la_mode = oattr->la_mode;
la->la_uid = oattr->la_uid;
if (((uc->uc_fsuid != oattr->la_uid) ||
(la->la_uid != oattr->la_uid)) &&
- !md_capable(uc, CFS_CAP_CHOWN))
+ !md_capable(uc, CAP_CHOWN))
RETURN(-EPERM);
/* If the user or group of a non-directory has been
if (((uc->uc_fsuid != oattr->la_uid) ||
((la->la_gid != oattr->la_gid) &&
!lustre_in_group_p(uc, la->la_gid))) &&
- !md_capable(uc, CFS_CAP_CHOWN))
+ !md_capable(uc, CAP_CHOWN))
RETURN(-EPERM);
/* Likewise, if the user or group of a non-directory
enum changelog_rec_type type,
enum changelog_rec_flags clf_flags,
const struct lu_fid *fid,
+ const struct lu_fid *pfid,
const char *xattr_name,
struct thandle *handle)
{
reclen = llog_data_len(LLOG_CHANGELOG_HDR_SZ +
changelog_rec_offset(clf_flags & CLF_SUPPORTED,
xflags & CLFE_SUPPORTED));
- buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
+ buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_chlg_buf, reclen);
if (buf->lb_buf == NULL)
RETURN(-ENOMEM);
rec = buf->lb_buf;
rec->cr.cr_flags = clf_flags;
rec->cr.cr_type = (__u32)type;
rec->cr.cr_tfid = *fid;
+ if (pfid)
+ rec->cr.cr_pfid = *pfid;
rec->cr.cr_namelen = 0;
if (clf_flags & CLF_JOBID)
* want the change to commit without the log entry.
* \param mdd_obj - mdd_object of change
* \param handle - transaction handle
+ * \param pfid - parent FID for CL_MTIME changelogs
*/
int mdd_changelog_data_store(const struct lu_env *env, struct mdd_device *mdd,
enum changelog_rec_type type,
enum changelog_rec_flags clf_flags,
- struct mdd_object *mdd_obj, struct thandle *handle)
+ struct mdd_object *mdd_obj, struct thandle *handle,
+ const struct lu_fid *pfid)
{
int rc;
}
rc = mdd_changelog_data_store_by_fid(env, mdd, type, clf_flags,
- mdd_object_fid(mdd_obj),
+ mdd_object_fid(mdd_obj), pfid,
NULL, handle);
if (rc == 0)
mdd_obj->mod_cltime = ktime_get();
}
rc = mdd_changelog_data_store_by_fid(env, mdd, type, clf_flags,
- mdd_object_fid(mdd_obj),
+ mdd_object_fid(mdd_obj), NULL,
xattr_name, handle);
if (rc == 0)
mdd_obj->mod_cltime = ktime_get();
GOTO(stop, rc);
rc = mdd_changelog_data_store_by_fid(env, mdd, type, clf_flags,
- fid, NULL, handle);
+ fid, NULL, NULL, handle);
stop:
rc = mdd_trans_stop(env, mdd, rc, handle);
* atime and ctime are independent.) */
static int mdd_attr_set_changelog(const struct lu_env *env,
struct md_object *obj, struct thandle *handle,
- __u64 valid)
+ const struct lu_fid *pfid, __u64 valid)
{
struct mdd_device *mdd = mdo2mdd(obj);
int bits, type = 0;
- bits = (valid & LA_SIZE) ? 1 << CL_TRUNC : 0;
- bits |= (valid & ~(LA_CTIME|LA_MTIME|LA_ATIME)) ? 1 << CL_SETATTR : 0;
- bits |= (valid & LA_MTIME) ? 1 << CL_MTIME : 0;
- bits |= (valid & LA_CTIME) ? 1 << CL_CTIME : 0;
- bits |= (valid & LA_ATIME) ? 1 << CL_ATIME : 0;
+ bits = (valid & LA_SIZE) ? BIT(CL_TRUNC) : 0;
+ bits |= (valid & ~(LA_CTIME|LA_MTIME|LA_ATIME)) ? BIT(CL_SETATTR) : 0;
+ bits |= (valid & LA_MTIME) ? BIT(CL_MTIME) : 0;
+ bits |= (valid & LA_CTIME) ? BIT(CL_CTIME) : 0;
+ bits |= (valid & LA_ATIME) ? BIT(CL_ATIME) : 0;
bits = bits & mdd->mdd_cl.mc_mask;
/* This is an implementation limit rather than a protocol limit */
BUILD_BUG_ON(CL_LAST > sizeof(int) * 8);
type = __ffs(bits);
/* XXX: we only store the low CLF_FLAGMASK bits of la_valid */
- return mdd_changelog_data_store(env, mdd, type, valid,
- md2mdd_obj(obj), handle);
+ return mdd_changelog_data_store(env, mdd, type, valid, md2mdd_obj(obj),
+ handle, pfid);
}
static int mdd_declare_attr_set(const struct lu_env *env,
out:
if (rc == 0)
- rc = mdd_attr_set_changelog(env, obj, handle,
+ rc = mdd_attr_set_changelog(env, obj, handle, &ma->ma_pfid,
la_copy->la_valid);
if (handle != NULL)
* can write attributes. */
if (S_ISDIR(attr->la_mode) && (attr->la_mode & S_ISVTX) &&
(uc->uc_fsuid != attr->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
} else if (strcmp(name, XATTR_NAME_SOM) != 0 &&
(uc->uc_fsuid != attr->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER)) {
+ !md_capable(uc, CAP_FOWNER)) {
RETURN(-EPERM);
}
if (rc) /* wtf? */
GOTO(out_restore, rc);
- (void)mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle);
- (void)mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, vic, handle);
+ (void)mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle,
+ NULL);
+ (void)mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, vic, handle,
+ NULL);
EXIT;
out_restore:
{
struct mdd_device *mdd = mdo2mdd(md_obj);
struct mdd_object *obj = md2mdd_obj(md_obj);
- struct mdd_object *vic = md2mdd_obj(mrd->mrd_obj);
+ struct mdd_object *vic = NULL;
struct lu_buf *buf = &mdd_env_info(env)->mti_buf[0];
struct lu_buf *buf_save = &mdd_env_info(env)->mti_buf[1];
struct lu_buf *buf_vic = &mdd_env_info(env)->mti_buf[2];
ENTRY;
- rc = lu_fid_cmp(mdd_object_fid(obj), mdd_object_fid(vic));
- if (rc == 0) /* same fid */
- RETURN(-EPERM);
+ /**
+ * NULL @mrd_obj means mirror deleting, and use NULL vic to indicate
+ * mirror deleting
+ */
+ if (mrd->mrd_obj)
+ vic = md2mdd_obj(mrd->mrd_obj);
handle = mdd_trans_create(env, mdd);
if (IS_ERR(handle))
RETURN(PTR_ERR(handle));
- if (rc > 0) {
- mdd_write_lock(env, obj, DT_TGT_CHILD);
- mdd_write_lock(env, vic, DT_TGT_CHILD);
- } else {
- mdd_write_lock(env, vic, DT_TGT_CHILD);
- mdd_write_lock(env, obj, DT_TGT_CHILD);
- }
-
/* get EA of mirrored file */
memset(buf_save, 0, sizeof(*buf));
rc = mdd_stripe_get(env, obj, buf_save, XATTR_NAME_LOV);
if (rc < 0)
- GOTO(out, rc);
+ GOTO(stop, rc);
lcm = buf_save->lb_buf;
if (le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_COMP_V1)
- GOTO(out, rc = -EINVAL);
+ GOTO(stop, rc = -EINVAL);
/**
* Extract the mirror with specified mirror id, and store the splitted
- * mirror layout to the victim file.
+ * mirror layout to the victim buffer.
*/
memset(buf, 0, sizeof(*buf));
memset(buf_vic, 0, sizeof(*buf_vic));
rc = mdd_split_ea(lcm, mrd->mrd_mirror_id, buf, buf_vic);
if (rc < 0)
- GOTO(out, rc);
+ GOTO(stop, rc);
+ /**
+ * @buf stores layout w/o the specified mirror, @buf_vic stores the
+ * splitted mirror
+ */
dom_stripe = mdd_lmm_dom_size(buf_vic->lb_buf) > 0;
- rc = mdd_declare_xattr_set(env, mdd, obj, buf, XATTR_NAME_LOV,
- LU_XATTR_SPLIT, handle);
- if (rc)
- GOTO(out, rc);
- rc = mdd_declare_xattr_set(env, mdd, vic, buf_vic, XATTR_NAME_LOV,
- LU_XATTR_SPLIT, handle);
- if (rc)
- GOTO(out, rc);
+ if (vic) {
+ /**
+ * non delete mirror split
+ *
+ * declare obj set remaining layout in @buf, will set obj's
+ * in-memory layout
+ */
+ rc = mdd_declare_xattr_set(env, mdd, obj, buf, XATTR_NAME_LOV,
+ LU_XATTR_SPLIT, handle);
+ if (rc)
+ GOTO(stop, rc);
+
+ /* declare vic set splitted layout in @buf_vic */
+ rc = mdd_declare_xattr_set(env, mdd, vic, buf_vic,
+ XATTR_NAME_LOV, LU_XATTR_SPLIT,
+ handle);
+ if (rc)
+ GOTO(stop, rc);
+ } else {
+ /**
+ * declare delete mirror objects in @buf_vic, will change obj's
+ * in-memory layout
+ */
+ rc = mdd_declare_xattr_set(env, mdd, obj, buf_vic,
+ XATTR_NAME_LOV, LU_XATTR_PURGE,
+ handle);
+ if (rc)
+ GOTO(stop, rc);
+
+ /* declare obj set remaining layout in @buf */
+ rc = mdd_declare_xattr_set(env, mdd, obj, buf,
+ XATTR_NAME_LOV, LU_XATTR_SPLIT,
+ handle);
+ if (rc)
+ GOTO(stop, rc);
+ }
rc = mdd_trans_start(env, mdd, handle);
if (rc)
- GOTO(out, rc);
+ GOTO(stop, rc);
+
+ if (vic) {
+ /* don't use the same file to save the splitted mirror */
+ rc = lu_fid_cmp(mdd_object_fid(obj), mdd_object_fid(vic));
+ if (rc == 0)
+ GOTO(stop, rc = -EPERM);
+
+ if (rc > 0) {
+ mdd_write_lock(env, obj, DT_TGT_CHILD);
+ mdd_write_lock(env, vic, DT_TGT_CHILD);
+ } else {
+ mdd_write_lock(env, vic, DT_TGT_CHILD);
+ mdd_write_lock(env, obj, DT_TGT_CHILD);
+ }
+ } else {
+ mdd_write_lock(env, obj, DT_TGT_CHILD);
+ }
+ /* set obj's layout in @buf */
rc = mdo_xattr_set(env, obj, buf, XATTR_NAME_LOV, LU_XATTR_REPLACE,
handle);
if (rc)
- GOTO(out, rc);
+ GOTO(unlock, rc);
- rc = mdo_xattr_set(env, vic, buf_vic, XATTR_NAME_LOV, LU_XATTR_CREATE,
- handle);
- if (rc)
- GOTO(out_restore, rc);
+ if (vic) {
+ /* set vic's layout in @buf_vic */
+ rc = mdo_xattr_set(env, vic, buf_vic, XATTR_NAME_LOV,
+ LU_XATTR_CREATE, handle);
+ if (rc)
+ GOTO(out_restore, rc);
+ } else {
+ /* delete mirror objects */
+ rc = mdo_xattr_set(env, obj, buf_vic, XATTR_NAME_LOV,
+ LU_XATTR_PURGE, handle);
+ if (rc)
+ GOTO(out_restore, rc);
+ }
- rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle,
+ NULL);
if (rc)
- GOTO(out, rc);
+ GOTO(out_restore, rc);
- rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, vic, handle);
- if (rc)
- GOTO(out, rc);
- EXIT;
+ if (vic) {
+ rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, vic,
+ handle, NULL);
+ if (rc)
+ GOTO(out_restore, rc);
+ }
out_restore:
if (rc) {
- /* restore obj's layout */
+ /* restore obj's in-memory and on-disk layout */
int rc2 = mdo_xattr_set(env, obj, buf_save, XATTR_NAME_LOV,
LU_XATTR_REPLACE, handle);
if (rc2)
- CERROR("%s: failed rollback "DFID" layout: file state unkonwn: rc = %d\n",
+ CERROR("%s: failed rollback "DFID
+ " layout: file state unknown: rc = %d\n",
mdd_obj_dev_name(obj),
- PFID(mdd_object_fid(obj)), rc2);
+ PFID(mdd_object_fid(obj)), rc);
}
-out:
+
+unlock:
+ mdd_write_unlock(env, obj);
+ if (vic)
+ mdd_write_unlock(env, vic);
+stop:
rc = mdd_trans_stop(env, mdd, rc, handle);
/* Truncate local DOM data if all went well */
if (!rc && dom_stripe)
mdd_dom_data_truncate(env, mdd, obj);
- mdd_write_unlock(env, obj);
- mdd_write_unlock(env, vic);
lu_buf_free(buf_save);
lu_buf_free(buf);
lu_buf_free(buf_vic);
if (buf->lb_len != sizeof(*mrd))
RETURN(-EINVAL);
- rc = mdd_layout_merge_allowed(env, obj, victim);
- if (rc)
- RETURN(rc);
- if (fl == LU_XATTR_MERGE)
+ if (fl == LU_XATTR_MERGE) {
+ rc = mdd_layout_merge_allowed(env, obj, victim);
+ if (rc)
+ RETURN(rc);
/* merge layout of victim as a mirror of obj's. */
rc = mdd_xattr_merge(env, obj, victim);
- else
+ } else {
rc = mdd_xattr_split(env, obj, mrd);
+ }
RETURN(rc);
}
/* Add a changelog record for release. */
hsm_set_cl_event(&clf_flags, HE_RELEASE);
rc = mdd_changelog_data_store(env, mdo2mdd(&o->mod_obj), CL_HSM,
- clf_flags, o, handle);
+ clf_flags, o, handle, NULL);
RETURN(rc);
}
GOTO(out_restore, rc);
/* Issue one changelog record per file */
- rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, fst_o, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, fst_o, handle,
+ NULL);
if (rc)
GOTO(stop, rc);
- rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, snd_o, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, snd_o, handle,
+ NULL);
if (rc)
GOTO(stop, rc);
EXIT;
if (rc)
RETURN(rc);
- rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_LAYOUT, 0, obj, handle,
+ NULL);
RETURN(rc);
}
lustre_som_swab(som);
if (som->lsa_valid & SOM_FL_STRICT)
fl = LU_XATTR_REPLACE;
+
+ if (mlc->mlc_opc == MD_LAYOUT_WRITE &&
+ mlc->mlc_intent->li_extent.e_end > som->lsa_size) {
+ som->lsa_size = mlc->mlc_intent->li_extent.e_end + 1;
+ fl = LU_XATTR_REPLACE;
+ }
}
rc = mdd_declare_layout_change(env, mdd, obj, mlc, handle);
if (rc)
GOTO(out, rc);
- rc = mdd_changelog_data_store(env, mdd, CL_FLRW, 0, obj, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_FLRW, 0, obj, handle, NULL);
if (rc)
GOTO(out, rc);
struct thandle *handle)
{
struct mdd_device *mdd = mdd_obj2mdd_dev(obj);
+ struct lu_buf *som_buf = &mdd_env_info(env)->mti_buf[1];
+ struct lustre_som_attrs *som = &mlc->mlc_som;
+ int fl = 0;
int rc;
ENTRY;
* resync state. */
break;
case MD_LAYOUT_WRITE:
- /* legal race for concurrent write, the file state has been
- * changed by another client. */
+ /**
+ * legal race for concurrent write, the file state has been
+ * changed by another client. Or a jump over file size and
+ * write.
+ */
+ som_buf->lb_buf = som;
+ som_buf->lb_len = sizeof(*som);
+ rc = mdo_xattr_get(env, obj, som_buf, XATTR_NAME_SOM);
+ if (rc < 0 && rc != -ENODATA)
+ RETURN(rc);
+
+ if (rc > 0) {
+ lustre_som_swab(som);
+ if (mlc->mlc_intent->li_extent.e_end > som->lsa_size) {
+ som->lsa_size =
+ mlc->mlc_intent->li_extent.e_end + 1;
+ fl = LU_XATTR_REPLACE;
+ }
+ }
break;
default:
RETURN(-EBUSY);
if (rc)
GOTO(out, rc);
+ if (fl) {
+ rc = mdd_declare_xattr_set(env, mdd, obj, som_buf,
+ XATTR_NAME_SOM, fl, handle);
+ if (rc)
+ GOTO(out, rc);
+ }
+
rc = mdd_trans_start(env, mdd, handle);
if (rc)
GOTO(out, rc);
mdd_write_lock(env, obj, DT_TGT_CHILD);
rc = mdo_layout_change(env, obj, mlc, handle);
+ if (!rc && fl) {
+ som->lsa_valid = SOM_FL_STALE;
+ lustre_som_swab(som);
+ rc = mdo_xattr_set(env, obj, som_buf, XATTR_NAME_SOM,
+ fl, handle);
+ }
mdd_write_unlock(env, obj);
if (rc)
GOTO(out, rc);
GOTO(out, rc);
}
- rc = mdd_changelog_data_store(env, mdd, CL_RESYNC, 0, obj, handle);
+ rc = mdd_changelog_data_store(env, mdd, CL_RESYNC, 0, obj, handle,
+ NULL);
if (rc)
GOTO(out, rc);
EXIT;
case MD_LAYOUT_SHRINK:
rc = mdd_dir_layout_shrink(env, o, mlc);
break;
+ case MD_LAYOUT_SPLIT:
+ rc = mdd_dir_layout_split(env, o, mlc);
+ break;
default:
LBUG();
}
nc->do_ops->do_ah_init(env, hint, np, nc, attr->la_mode & S_IFMT);
}
-static int accmode(const struct lu_env *env, const struct lu_attr *la,
- u64 open_flags)
+static int mdd_accmode(const struct lu_env *env, const struct lu_attr *la,
+ u64 open_flags)
{
/* Sadly, NFSD reopens a file repeatedly during operation, so the
* "acc_mode = 0" allowance for newly-created files isn't honoured.
const struct lu_attr *attr, u64 open_flags,
int is_replay)
{
- int mode, rc;
+ unsigned int may_mask;
+ int rc;
ENTRY;
/* EEXIST check, also opening of *open* orphans is allowed so we can
if (S_ISLNK(attr->la_mode))
RETURN(-ELOOP);
- mode = accmode(env, attr, open_flags);
+ may_mask = mdd_accmode(env, attr, open_flags);
- if (S_ISDIR(attr->la_mode) && (mode & MAY_WRITE))
+ if (S_ISDIR(attr->la_mode) && (may_mask & MAY_WRITE))
RETURN(-EISDIR);
if (!(open_flags & MDS_OPEN_CREATED)) {
- rc = mdd_permission_internal(env, obj, attr, mode);
+ rc = mdd_permission_internal(env, obj, attr, may_mask);
if (rc)
RETURN(rc);
}
rc = mdd_open_sanity_check(env, mdd_obj, attr, open_flags,
spec->no_create);
- if ((rc == -EACCES) && (mdd->mdd_cl.mc_mask & (1 << CL_DN_OPEN)))
+ if ((rc == -EACCES) && (mdd->mdd_cl.mc_mask & BIT(CL_DN_OPEN)))
type = CL_DN_OPEN;
else if (rc != 0)
GOTO(out, rc);
* this is not a big deal if we have a CL_CLOSE entry with no matching
* CL_OPEN. Plus Changelogs mask may not change often.
*/
- if (((!(mdd->mdd_cl.mc_mask & (1 << CL_OPEN)) &&
+ if (((!(mdd->mdd_cl.mc_mask & BIT(CL_OPEN)) &&
(open_flags & (MDS_FMODE_WRITE | MDS_OPEN_APPEND |
MDS_OPEN_TRUNC))) ||
- ((mdd->mdd_cl.mc_mask & (1 << CL_OPEN)) && last_close_by_uid)) &&
+ ((mdd->mdd_cl.mc_mask & BIT(CL_OPEN)) && last_close_by_uid)) &&
!(ma->ma_valid & MA_FLAGS && ma->ma_attr_flags & MDS_RECOV_OPEN)) {
if (handle == NULL) {
handle = mdd_trans_create(env, mdo2mdd(obj));
/* FYI, only the bottom 32 bits of open_flags are recorded */
mdd_changelog_data_store(env, mdd, CL_CLOSE, open_flags,
- mdd_obj, handle);
+ mdd_obj, handle, NULL);
}
stop: