Exemple #1
0
static int __out_tx_xattr_set(const struct lu_env *env,
			      struct dt_object *dt_obj,
			      const struct lu_buf *buf,
			      const char *name, int flags,
			      struct thandle_exec_args *ta,
			      struct update_reply *reply, int index,
			      char *file, int line)
{
	struct tx_arg		*arg;

	LASSERT(ta->ta_handle != NULL);
	ta->ta_err = dt_declare_xattr_set(env, dt_obj, buf, name,
					  flags, ta->ta_handle);
	if (ta->ta_err != 0)
		return ta->ta_err;

	arg = tx_add_exec(ta, out_tx_xattr_set_exec, NULL, file, line);
	LASSERT(arg);
	lu_object_get(&dt_obj->do_lu);
	arg->object = dt_obj;
	arg->u.xattr_set.name = name;
	arg->u.xattr_set.flags = flags;
	arg->u.xattr_set.buf = *buf;
	arg->reply = reply;
	arg->index = index;
	arg->u.xattr_set.csum = 0;
	return 0;
}
Exemple #2
0
static int lfsck_update_lma(const struct lu_env *env,
			    struct lfsck_instance *lfsck, struct dt_object *obj)
{
	struct lfsck_thread_info	*info	= lfsck_env_info(env);
	struct lfsck_bookmark		*bk	= &lfsck->li_bookmark_ram;
	struct dt_device		*dt	= lfsck->li_bottom;
	struct lustre_mdt_attrs 	*lma	= &info->lti_lma;
	struct lu_buf			*buf;
	struct thandle			*th;
	int				 fl;
	int				 rc;
	ENTRY;

	if (bk->lb_param & LPF_DRYRUN)
		RETURN(0);

	buf = lfsck_buf_get(env, info->lti_lma_old, LMA_OLD_SIZE);
	rc = dt_xattr_get(env, obj, buf, XATTR_NAME_LMA, BYPASS_CAPA);
	if (rc < 0) {
		if (rc != -ENODATA)
			RETURN(rc);

		fl = LU_XATTR_CREATE;
		lustre_lma_init(lma, lfsck_dto2fid(obj), LMAC_FID_ON_OST, 0);
	} else {
		if (rc != LMA_OLD_SIZE && rc != sizeof(struct lustre_mdt_attrs))
			RETURN(-EINVAL);

		fl = LU_XATTR_REPLACE;
		lustre_lma_swab(lma);
		lustre_lma_init(lma, lfsck_dto2fid(obj),
				lma->lma_compat | LMAC_FID_ON_OST,
				lma->lma_incompat);
	}
	lustre_lma_swab(lma);

	th = dt_trans_create(env, dt);
	if (IS_ERR(th))
		RETURN(PTR_ERR(th));

	buf = lfsck_buf_get(env, lma, sizeof(*lma));
	rc = dt_declare_xattr_set(env, obj, buf, XATTR_NAME_LMA, fl, th);
	if (rc != 0)
		GOTO(stop, rc);

	rc = dt_trans_start(env, dt, th);
	if (rc != 0)
		GOTO(stop, rc);

	rc = dt_xattr_set(env, obj, buf, XATTR_NAME_LMA, fl, th, BYPASS_CAPA);

	GOTO(stop, rc);

stop:
	dt_trans_stop(env, dt, th);
	return rc;
}
static int lfsck_namespace_store(const struct lu_env *env,
				 struct lfsck_component *com, bool init)
{
	struct dt_object	*obj    = com->lc_obj;
	struct lfsck_instance	*lfsck  = com->lc_lfsck;
	struct thandle		*handle;
	int			 len    = com->lc_file_size;
	int			 rc;
	ENTRY;

	lfsck_namespace_cpu_to_le((struct lfsck_namespace *)com->lc_file_disk,
				  (struct lfsck_namespace *)com->lc_file_ram);
	handle = dt_trans_create(env, lfsck->li_bottom);
	if (IS_ERR(handle)) {
		rc = PTR_ERR(handle);
		CERROR("%s: fail to create trans for storing lfsck_namespace: "
		       "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
		RETURN(rc);
	}

	rc = dt_declare_xattr_set(env, obj,
				  lfsck_buf_get(env, com->lc_file_disk, len),
				  XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
	if (rc != 0) {
		CERROR("%s: fail to declare trans for storing lfsck_namespace: "
		       "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
		GOTO(out, rc);
	}

	rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
	if (rc != 0) {
		CERROR("%s: fail to start trans for storing lfsck_namespace: "
		       "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
		GOTO(out, rc);
	}

	rc = dt_xattr_set(env, obj,
			  lfsck_buf_get(env, com->lc_file_disk, len),
			  XATTR_NAME_LFSCK_NAMESPACE,
			  init ? LU_XATTR_CREATE : LU_XATTR_REPLACE,
			  handle, BYPASS_CAPA);
	if (rc != 0)
		CERROR("%s: fail to store lfsck_namespace: len = %d, "
		       "rc = %d\n", lfsck_lfsck2name(lfsck), len, rc);

	GOTO(out, rc);

out:
	dt_trans_stop(env, lfsck->li_bottom, handle);
	return rc;
}
static int lfsck_declare_namespace_exec_dir(const struct lu_env *env,
					    struct dt_object *obj,
					    struct thandle *handle)
{
	int rc;

	/* For destroying all invalid linkEA entries. */
	rc = dt_declare_xattr_del(env, obj, XATTR_NAME_LINK, handle);
	if (rc != 0)
		return rc;

	/* For insert new linkEA entry. */
	rc = dt_declare_xattr_set(env, obj,
			lfsck_buf_get_const(env, NULL, DEFAULT_LINKEA_SIZE),
			XATTR_NAME_LINK, 0, handle);
	return rc;
}
Exemple #5
0
/**
 * Set attributes of object during write bulk IO processing.
 *
 * Change object attributes and write parent FID into extended
 * attributes when needed.
 *
 * \param[in] env	execution environment
 * \param[in] ofd	OFD device
 * \param[in] ofd_obj	OFD object
 * \param[in] la	object attributes
 * \param[in] ff	parent FID
 *
 * \retval		0 on successful attributes update
 * \retval		negative value on error
 */
static int
ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd,
		   struct ofd_object *ofd_obj, struct lu_attr *la,
		   struct filter_fid *ff)
{
	struct ofd_thread_info	*info = ofd_info(env);
	__u64			 valid = la->la_valid;
	int			 rc;
	struct thandle		*th;
	struct dt_object	*dt_obj;
	int			 ff_needed = 0;

	ENTRY;

	LASSERT(la);

	dt_obj = ofd_object_child(ofd_obj);
	LASSERT(dt_obj != NULL);

	la->la_valid &= LA_UID | LA_GID;

	rc = ofd_attr_handle_ugid(env, ofd_obj, la, 0 /* !is_setattr */);
	if (rc != 0)
		GOTO(out, rc);

	if (ff != NULL) {
		rc = ofd_object_ff_load(env, ofd_obj);
		if (rc == -ENODATA)
			ff_needed = 1;
		else if (rc < 0)
			GOTO(out, rc);
	}

	if (!la->la_valid && !ff_needed)
		/* no attributes to set */
		GOTO(out, rc = 0);

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(out, rc = PTR_ERR(th));

	if (la->la_valid) {
		rc = dt_declare_attr_set(env, dt_obj, la, th);
		if (rc)
			GOTO(out_tx, 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);

		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf,
					  XATTR_NAME_FID, 0, th);
		if (rc)
			GOTO(out_tx, rc);
	}

	/* We don't need a transno for this operation which will be re-executed
	 * anyway when the OST_WRITE (with a transno assigned) is replayed */
	rc = dt_trans_start_local(env, ofd->ofd_osd , th);
	if (rc)
		GOTO(out_tx, rc);

	/* set uid/gid */
	if (la->la_valid) {
		rc = dt_attr_set(env, dt_obj, la, th);
		if (rc)
			GOTO(out_tx, rc);
	}

	/* set filter fid EA */
	if (ff_needed) {
		if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NOPFID))
			GOTO(out_tx, 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);
		}
	}

	GOTO(out_tx, rc);

out_tx:
	dt_trans_stop(env, ofd->ofd_osd, th);
out:
	la->la_valid = valid;
	return rc;
}
Exemple #6
0
int ofd_object_punch(const struct lu_env *env, struct ofd_object *fo,
		     __u64 start, __u64 end, struct lu_attr *la,
		     struct filter_fid *ff, struct obdo *oa)
{
	struct ofd_thread_info	*info = ofd_info(env);
	struct ofd_device	*ofd = ofd_obj2dev(fo);
	struct ofd_mod_data	*fmd;
	struct dt_object	*dob = ofd_object_child(fo);
	struct thandle		*th;
	int			 ff_needed = 0;
	int			 rc;

	ENTRY;

	/* we support truncate, not punch yet */
	LASSERT(end == OBD_OBJECT_EOF);

	fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid);
	if (fmd && fmd->fmd_mactime_xid < info->fti_xid)
		fmd->fmd_mactime_xid = info->fti_xid;
	ofd_fmd_put(info->fti_exp, fmd);

	ofd_write_lock(env, fo);
	if (!ofd_object_exists(fo))
		GOTO(unlock, rc = -ENOENT);

	if (ofd->ofd_lfsck_verify_pfid && oa->o_valid & OBD_MD_FLFID) {
		rc = ofd_verify_ff(env, fo, oa);
		if (rc != 0)
			GOTO(unlock, rc);
	}

	/* VBR: version recovery check */
	rc = ofd_version_get_check(info, fo);
	if (rc)
		GOTO(unlock, rc);

	rc = ofd_attr_handle_ugid(env, fo, la, 0 /* !is_setattr */);
	if (rc != 0)
		GOTO(unlock, rc);

	if (ff != NULL) {
		rc = ofd_object_ff_load(env, fo);
		if (rc == -ENODATA)
			ff_needed = 1;
		else if (rc < 0)
			GOTO(unlock, rc);
	}

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(unlock, rc = PTR_ERR(th));

	rc = dt_declare_attr_set(env, dob, la, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_declare_punch(env, dob, start, OBD_OBJECT_EOF, th);
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_declare_xattr_set(env, ofd_object_child(fo),
					  &info->fti_buf, XATTR_NAME_FID, 0,
					  th);
		if (rc)
			GOTO(stop, rc);
	}

	rc = ofd_trans_start(env, ofd, fo, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_punch(env, dob, start, OBD_OBJECT_EOF, th,
		      ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	rc = dt_attr_set(env, dob, la, th, ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
				  XATTR_NAME_FID, 0, th, BYPASS_CAPA);
		if (rc == 0) {
			fo->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq);
			fo->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. */
			fo->ofo_pfid.f_stripe_idx =
					le32_to_cpu(ff->ff_parent.f_stripe_idx);
		}
	}

	GOTO(stop, rc);

stop:
	ofd_trans_stop(env, ofd, th, rc);
unlock:
	ofd_write_unlock(env, fo);

	return rc;
}
Exemple #7
0
int ofd_attr_set(const struct lu_env *env, struct ofd_object *fo,
		 struct lu_attr *la, struct filter_fid *ff)
{
	struct ofd_thread_info	*info = ofd_info(env);
	struct ofd_device	*ofd = ofd_obj2dev(fo);
	struct thandle		*th;
	struct ofd_mod_data	*fmd;
	int			 ff_needed = 0;
	int			 rc;
	ENTRY;

	ofd_write_lock(env, fo);
	if (!ofd_object_exists(fo))
		GOTO(unlock, rc = -ENOENT);

	if (la->la_valid & (LA_ATIME | LA_MTIME | LA_CTIME)) {
		fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid);
		if (fmd && fmd->fmd_mactime_xid < info->fti_xid)
			fmd->fmd_mactime_xid = info->fti_xid;
		ofd_fmd_put(info->fti_exp, fmd);
	}

	/* VBR: version recovery check */
	rc = ofd_version_get_check(info, fo);
	if (rc)
		GOTO(unlock, rc);

	rc = ofd_attr_handle_ugid(env, fo, la, 1 /* is_setattr */);
	if (rc != 0)
		GOTO(unlock, rc);

	if (ff != NULL) {
		rc = ofd_object_ff_load(env, fo);
		if (rc == -ENODATA)
			ff_needed = 1;
		else if (rc < 0)
			GOTO(unlock, rc);
	}

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(unlock, rc = PTR_ERR(th));

	rc = dt_declare_attr_set(env, ofd_object_child(fo), la, th);
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_declare_xattr_set(env, ofd_object_child(fo),
					  &info->fti_buf, XATTR_NAME_FID, 0,
					  th);
		if (rc)
			GOTO(stop, rc);
	}

	rc = ofd_trans_start(env, ofd, la->la_valid & LA_SIZE ? fo : NULL, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_attr_set(env, ofd_object_child(fo), la, th,
			 ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
				  XATTR_NAME_FID, 0, th, BYPASS_CAPA);
		if (rc == 0) {
			fo->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq);
			fo->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. */
			fo->ofo_pfid.f_stripe_idx =
					le32_to_cpu(ff->ff_parent.f_stripe_idx);
		}
	}

	GOTO(stop, rc);

stop:
	ofd_trans_stop(env, ofd, th, rc);
unlock:
	ofd_write_unlock(env, fo);

	return rc;
}
Exemple #8
0
/**
 * Set attributes of object during write bulk IO processing.
 *
 * Change object attributes and write parent FID into extended
 * attributes when needed.
 *
 * \param[in] env	execution environment
 * \param[in] ofd	OFD device
 * \param[in] ofd_obj	OFD object
 * \param[in] la	object attributes
 * \param[in] oa	obdo
 *
 * \retval		0 on successful attributes update
 * \retval		negative value on error
 */
static int
ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd,
		   struct ofd_object *ofd_obj, struct lu_attr *la,
		   struct obdo *oa)
{
	struct ofd_thread_info	*info = ofd_info(env);
	struct filter_fid	*ff = &info->fti_mds_fid;
	__u64			 valid = la->la_valid;
	struct thandle		*th;
	struct dt_object	*dt_obj;
	int			 fl = 0;
	int			 rc;

	ENTRY;

	LASSERT(la);

	dt_obj = ofd_object_child(ofd_obj);
	LASSERT(dt_obj != NULL);

	la->la_valid &= LA_UID | LA_GID | LA_PROJID;

	rc = ofd_attr_handle_id(env, ofd_obj, la, 0 /* !is_setattr */);
	if (rc != 0)
		GOTO(out, rc);

	fl = ofd_object_ff_update(env, ofd_obj, oa, ff);
	if (fl < 0)
		GOTO(out, rc = fl);

	if (!la->la_valid && !fl)
		/* no attributes to set */
		GOTO(out, rc = 0);

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(out, rc = PTR_ERR(th));

	if (la->la_valid) {
		rc = dt_declare_attr_set(env, dt_obj, la, th);
		if (rc)
			GOTO(out_tx, rc);
	}

	if (fl) {
		if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR1))
			ff->ff_parent.f_oid = cpu_to_le32(1UL << 31);
		else if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR2))
			le32_add_cpu(&ff->ff_parent.f_oid, -1);

		rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf,
					  XATTR_NAME_FID, 0, th);
		if (rc)
			GOTO(out_tx, rc);
	}

	/* We don't need a transno for this operation which will be re-executed
	 * anyway when the OST_WRITE (with a transno assigned) is replayed */
	rc = dt_trans_start_local(env, ofd->ofd_osd , th);
	if (rc)
		GOTO(out_tx, rc);

	/* set uid/gid/projid */
	if (la->la_valid) {
		rc = dt_attr_set(env, dt_obj, la, th);
		if (rc)
			GOTO(out_tx, rc);
	}

	/* set filter fid EA.
	 * FIXME: it holds read lock of ofd object to modify the XATTR_NAME_FID
	 * while the write lock should be held. However, it should work because
	 * write RPCs only modify ff_{parent,layout} and those information will
	 * be the same from all the write RPCs. The reason that fl is not used
	 * in dt_xattr_set() is to allow this race. */
	if (fl) {
		if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NOPFID))
			GOTO(out_tx, rc);

		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID,
				  0, th);
		if (rc == 0)
			filter_fid_le_to_cpu(&ofd_obj->ofo_ff, ff, sizeof(*ff));
	}

	GOTO(out_tx, rc);

out_tx:
	dt_trans_stop(env, ofd->ofd_osd, th);
out:
	la->la_valid = valid;
	return rc;
}
Exemple #9
0
int ofd_object_punch(const struct lu_env *env, struct ofd_object *fo,
		     __u64 start, __u64 end, struct lu_attr *la,
		     struct filter_fid *ff)
{
	struct ofd_thread_info	*info = ofd_info(env);
	struct ofd_device	*ofd = ofd_obj2dev(fo);
	struct ofd_mod_data	*fmd;
	struct dt_object	*dob = ofd_object_child(fo);
	struct thandle		*th;
	int			 ff_needed = 0;
	int			 rc;

	ENTRY;

	/* we support truncate, not punch yet */
	LASSERT(end == OBD_OBJECT_EOF);

	fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid);
	if (fmd && fmd->fmd_mactime_xid < info->fti_xid)
		fmd->fmd_mactime_xid = info->fti_xid;
	ofd_fmd_put(info->fti_exp, fmd);

	ofd_write_lock(env, fo);
	if (!ofd_object_exists(fo))
		GOTO(unlock, rc = -ENOENT);

	/* VBR: version recovery check */
	rc = ofd_version_get_check(info, fo);
	if (rc)
		GOTO(unlock, rc);

	rc = ofd_attr_handle_ugid(env, fo, la, 0 /* !is_setattr */);
	if (rc != 0)
		GOTO(unlock, rc);

	if (ff != NULL) {
		rc = ofd_object_ff_check(env, fo);
		if (rc == -ENODATA)
			ff_needed = 1;
		else if (rc < 0)
			GOTO(unlock, rc);
	}

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(unlock, rc = PTR_ERR(th));

	rc = dt_declare_attr_set(env, dob, la, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_declare_punch(env, dob, start, OBD_OBJECT_EOF, th);
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_declare_xattr_set(env, ofd_object_child(fo),
					  &info->fti_buf, XATTR_NAME_FID, 0,
					  th);
		if (rc)
			GOTO(stop, rc);
	}

	rc = ofd_trans_start(env, ofd, fo, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_punch(env, dob, start, OBD_OBJECT_EOF, th,
		      ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	rc = dt_attr_set(env, dob, la, th, ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	if (ff_needed)
		rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
				  XATTR_NAME_FID, 0, th, BYPASS_CAPA);

stop:
	ofd_trans_stop(env, ofd, th, rc);
unlock:
	ofd_write_unlock(env, fo);
	RETURN(rc);
}
Exemple #10
0
int ofd_attr_set(const struct lu_env *env, struct ofd_object *fo,
		 struct lu_attr *la, struct filter_fid *ff)
{
	struct ofd_thread_info	*info = ofd_info(env);
	struct ofd_device	*ofd = ofd_obj2dev(fo);
	struct thandle		*th;
	struct ofd_mod_data	*fmd;
	int			 ff_needed = 0;
	int			 rc;
	ENTRY;

	ofd_write_lock(env, fo);
	if (!ofd_object_exists(fo))
		GOTO(unlock, rc = -ENOENT);

	if (la->la_valid & (LA_ATIME | LA_MTIME | LA_CTIME)) {
		fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid);
		if (fmd && fmd->fmd_mactime_xid < info->fti_xid)
			fmd->fmd_mactime_xid = info->fti_xid;
		ofd_fmd_put(info->fti_exp, fmd);
	}

	/* VBR: version recovery check */
	rc = ofd_version_get_check(info, fo);
	if (rc)
		GOTO(unlock, rc);

	rc = ofd_attr_handle_ugid(env, fo, la, 1 /* is_setattr */);
	if (rc != 0)
		GOTO(unlock, rc);

	if (ff != NULL) {
		rc = ofd_object_ff_check(env, fo);
		if (rc == -ENODATA)
			ff_needed = 1;
		else if (rc < 0)
			GOTO(unlock, rc);
	}

	th = ofd_trans_create(env, ofd);
	if (IS_ERR(th))
		GOTO(unlock, rc = PTR_ERR(th));

	rc = dt_declare_attr_set(env, ofd_object_child(fo), la, th);
	if (rc)
		GOTO(stop, rc);

	if (ff_needed) {
		info->fti_buf.lb_buf = ff;
		info->fti_buf.lb_len = sizeof(*ff);
		rc = dt_declare_xattr_set(env, ofd_object_child(fo),
					  &info->fti_buf, XATTR_NAME_FID, 0,
					  th);
		if (rc)
			GOTO(stop, rc);
	}

	rc = ofd_trans_start(env, ofd, la->la_valid & LA_SIZE ? fo : NULL, th);
	if (rc)
		GOTO(stop, rc);

	rc = dt_attr_set(env, ofd_object_child(fo), la, th,
			 ofd_object_capa(env, fo));
	if (rc)
		GOTO(stop, rc);

	if (ff_needed)
		rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
				  XATTR_NAME_FID, 0, th, BYPASS_CAPA);

stop:
	ofd_trans_stop(env, ofd, th, rc);
unlock:
	ofd_write_unlock(env, fo);
	RETURN(rc);
}
Exemple #11
0
/**
 * \retval +ve	repaired
 * \retval 0	no need to repair
 * \retval -ve	error cases
 */
static int lfsck_namespace_double_scan_one(const struct lu_env *env,
					   struct lfsck_component *com,
					   struct dt_object *child, __u8 flags)
{
	struct lfsck_thread_info *info	  = lfsck_env_info(env);
	struct lu_attr		 *la	  = &info->lti_la;
	struct lu_name		 *cname	  = &info->lti_name;
	struct lu_fid		 *pfid	  = &info->lti_fid;
	struct lu_fid		 *cfid	  = &info->lti_fid2;
	struct lfsck_instance	*lfsck	  = com->lc_lfsck;
	struct lfsck_bookmark	*bk	  = &lfsck->li_bookmark_ram;
	struct lfsck_namespace	*ns	  = com->lc_file_ram;
	struct linkea_data	 ldata	  = { 0 };
	struct thandle		*handle   = NULL;
	bool			 locked   = false;
	bool			 update	  = false;
	int			 rc;
	ENTRY;

	if (com->lc_journal) {

again:
		LASSERT(!locked);

		update = false;
		com->lc_journal = 1;
		handle = dt_trans_create(env, lfsck->li_next);
		if (IS_ERR(handle))
			RETURN(rc = PTR_ERR(handle));

		rc = dt_declare_xattr_set(env, child,
			lfsck_buf_get_const(env, NULL, DEFAULT_LINKEA_SIZE),
			XATTR_NAME_LINK, 0, handle);
		if (rc != 0)
			GOTO(stop, rc);

		rc = dt_trans_start(env, lfsck->li_next, handle);
		if (rc != 0)
			GOTO(stop, rc);

		dt_write_lock(env, child, MOR_TGT_CHILD);
		locked = true;
	}

	if (unlikely(lfsck_is_dead_obj(child)))
		GOTO(stop, rc = 0);

	rc = dt_attr_get(env, child, la, BYPASS_CAPA);
	if (rc == 0)
		rc = lfsck_links_read(env, child, &ldata);
	if (rc != 0) {
		if ((bk->lb_param & LPF_DRYRUN) &&
		    (rc == -EINVAL || rc == -ENODATA))
			rc = 1;

		GOTO(stop, rc);
	}

	linkea_first_entry(&ldata);
	while (ldata.ld_lee != NULL) {
		struct dt_object *parent = NULL;

		rc = lfsck_linkea_entry_unpack(lfsck, &ldata, cname, pfid);
		if (rc > 0)
			update = true;

		if (!fid_is_sane(pfid))
			goto shrink;

		parent = lfsck_object_find(env, lfsck, pfid);
		if (parent == NULL)
			goto shrink;
		else if (IS_ERR(parent))
			GOTO(stop, rc = PTR_ERR(parent));

		if (!dt_object_exists(parent))
			goto shrink;

		/* XXX: Currently, skip remote object, the consistency for
		 *	remote object will be processed in LFSCK phase III. */
		if (dt_object_remote(parent)) {
			lfsck_object_put(env, parent);
			linkea_next_entry(&ldata);
			continue;
		}

		if (unlikely(!dt_try_as_dir(env, parent)))
			goto shrink;

		/* To guarantee the 'name' is terminated with '0'. */
		memcpy(info->lti_key, cname->ln_name, cname->ln_namelen);
		info->lti_key[cname->ln_namelen] = 0;
		cname->ln_name = info->lti_key;
		rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
			       (const struct dt_key *)cname->ln_name,
			       BYPASS_CAPA);
		if (rc != 0 && rc != -ENOENT) {
			lfsck_object_put(env, parent);
			GOTO(stop, rc);
		}

		if (rc == 0) {
			if (lu_fid_eq(cfid, lfsck_dto2fid(child))) {
				lfsck_object_put(env, parent);
				linkea_next_entry(&ldata);
				continue;
			}

			goto shrink;
		}

		/* If there is no name entry in the parent dir and the object
		 * link count is less than the linkea entries count, then the
		 * linkea entry should be removed. */
		if (ldata.ld_leh->leh_reccount > la->la_nlink)
			goto shrink;

		/* XXX: For the case of there is a linkea entry, but without
		 *	name entry pointing to the object and its hard links
		 *	count is not less than the object name entries count,
		 *	then seems we should add the 'missed' name entry back
		 *	to namespace, but before LFSCK phase III finished, we
		 *	do not know whether the object has some inconsistency
		 *	on other MDTs. So now, do NOT add the name entry back
		 *	to the namespace, but keep the linkEA entry. LU-2914 */
		lfsck_object_put(env, parent);
		linkea_next_entry(&ldata);
		continue;

shrink:
		if (parent != NULL)
			lfsck_object_put(env, parent);
		if (bk->lb_param & LPF_DRYRUN)
			RETURN(1);

		CDEBUG(D_LFSCK, "Remove linkEA: "DFID"[%.*s], "DFID"\n",
		       PFID(lfsck_dto2fid(child)), cname->ln_namelen, cname->ln_name,
		       PFID(pfid));
		linkea_del_buf(&ldata, cname);
		update = true;
	}

	if (update) {
		if (!com->lc_journal) {
			com->lc_journal = 1;
			goto again;
		}

		rc = lfsck_links_write(env, child, &ldata, handle);
	}

	GOTO(stop, rc);

stop:
	if (locked) {
	/* XXX: For the case linkea entries count does not match the object hard
	 *	links count, we cannot update the later one simply. Before LFSCK
	 *	phase III finished, we cannot know whether there are some remote
	 *	name entries to be repaired or not. LU-2914 */
		if (rc == 0 && !lfsck_is_dead_obj(child) &&
		    ldata.ld_leh != NULL &&
		    ldata.ld_leh->leh_reccount != la->la_nlink)
			CWARN("%s: the object "DFID" linkEA entry count %u "
			      "may not match its hardlink count %u\n",
			      lfsck_lfsck2name(lfsck), PFID(cfid),
			      ldata.ld_leh->leh_reccount, la->la_nlink);

		dt_write_unlock(env, child);
	}

	if (handle != NULL)
		dt_trans_stop(env, lfsck->li_next, handle);

	if (rc == 0 && update) {
		ns->ln_objs_nlink_repaired++;
		rc = 1;
	}

	return rc;
}
Exemple #12
0
static int
ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd,
                   struct ofd_object *ofd_obj, struct lu_attr *la,
                   struct filter_fid *ff)
{
    struct ofd_thread_info	*info = ofd_info(env);
    __u64			 valid = la->la_valid;
    int			 rc;
    struct thandle		*th;
    struct dt_object	*dt_obj;
    int			 ff_needed = 0;

    ENTRY;

    LASSERT(la);

    dt_obj = ofd_object_child(ofd_obj);
    LASSERT(dt_obj != NULL);

    la->la_valid &= LA_UID | LA_GID;

    rc = ofd_attr_handle_ugid(env, ofd_obj, la, 0 /* !is_setattr */);
    if (rc != 0)
        GOTO(out, rc);

    if (ff != NULL) {
        rc = ofd_object_ff_check(env, ofd_obj);
        if (rc == -ENODATA)
            ff_needed = 1;
        else if (rc < 0)
            GOTO(out, rc);
    }

    if (!la->la_valid && !ff_needed)
        /* no attributes to set */
        GOTO(out, rc = 0);

    th = ofd_trans_create(env, ofd);
    if (IS_ERR(th))
        GOTO(out, rc = PTR_ERR(th));

    if (la->la_valid) {
        rc = dt_declare_attr_set(env, dt_obj, la, th);
        if (rc)
            GOTO(out_tx, rc);
    }

    if (ff_needed) {
        info->fti_buf.lb_buf = ff;
        info->fti_buf.lb_len = sizeof(*ff);
        rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf,
                                  XATTR_NAME_FID, 0, th);
        if (rc)
            GOTO(out_tx, rc);
    }

    /* We don't need a transno for this operation which will be re-executed
     * anyway when the OST_WRITE (with a transno assigned) is replayed */
    rc = dt_trans_start_local(env, ofd->ofd_osd , th);
    if (rc)
        GOTO(out_tx, rc);

    /* set uid/gid */
    if (la->la_valid) {
        rc = dt_attr_set(env, dt_obj, la, th,
                         ofd_object_capa(env, ofd_obj));
        if (rc)
            GOTO(out_tx, rc);
    }

    /* set filter fid EA */
    if (ff_needed) {
        rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID,
                          0, th, BYPASS_CAPA);
        if (rc)
            GOTO(out_tx, rc);
    }

    EXIT;
out_tx:
    dt_trans_stop(env, ofd->ofd_osd, th);
out:
    la->la_valid = valid;
    return rc;
}