static const char dotdot[] = "..";
/**
- * Implementation of dt_object_operations::do_declare_create
+ * Add OUT_CREATE sub-request into the OUT RPC.
*
- * Insert object create update into the RPC, which will be sent during
- * transaction start. Note: if the object has already been created,
- * we must add object destroy updates ahead of create updates, so it will
- * destroy then recreate the object.
+ * Note: if the object has already been created, we must add object
+ * destroy sub-request ahead of the create, so it will destroy then
+ * re-create the object.
*
* \param[in] env execution environment
- * \param[in] dt remote object to be created
+ * \param[in] dt object to be created
* \param[in] attr attribute of the created object
* \param[in] hint creation hint
* \param[in] dof creation format information
* \param[in] th the transaction handle
*
- * \retval 0 if the insertion succeeds.
- * \retval negative errno if the insertion fails.
+ * \retval only return 0 for now
*/
-int osp_md_declare_object_create(const struct lu_env *env,
- struct dt_object *dt,
- struct lu_attr *attr,
- struct dt_allocation_hint *hint,
- struct dt_object_format *dof,
- struct thandle *th)
+static int __osp_md_declare_object_create(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lu_attr *attr,
+ struct dt_allocation_hint *hint,
+ struct dt_object_format *dof,
+ struct thandle *th)
{
struct dt_update_request *update;
int rc;
}
/**
+ * Implementation of dt_object_operations::do_declare_create
+ *
+ * For non-remote transaction, it will add an OUT_CREATE sub-request
+ * into the OUT RPC that will be flushed when the transaction start.
+ *
+ * \param[in] env execution environment
+ * \param[in] dt remote object to be created
+ * \param[in] attr attribute of the created object
+ * \param[in] hint creation hint
+ * \param[in] dof creation format information
+ * \param[in] th the transaction handle
+ *
+ * \retval 0 if the insertion succeeds.
+ * \retval negative errno if the insertion fails.
+ */
+int osp_md_declare_object_create(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lu_attr *attr,
+ struct dt_allocation_hint *hint,
+ struct dt_object_format *dof,
+ struct thandle *th)
+{
+ int rc = 0;
+
+ if (!is_only_remote_trans(th)) {
+ rc = __osp_md_declare_object_create(env, dt, attr, hint,
+ dof, th);
+
+ CDEBUG(D_INFO, "declare create md_object "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
+}
+
+/**
* Implementation of dt_object_operations::do_create
*
+ * For remote transaction, it will add an OUT_CREATE sub-request into
+ * the OUT RPC that will be flushed when the transaction stop.
+ *
* It sets necessary flags for created object. In DNE phase I,
* remote updates are actually executed during transaction start,
* i.e. the object has already been created when calling this method.
struct lu_attr *attr, struct dt_allocation_hint *hint,
struct dt_object_format *dof, struct thandle *th)
{
- CDEBUG(D_INFO, "create object "DFID"\n",
- PFID(&dt->do_lu.lo_header->loh_fid));
+ int rc = 0;
- /* Because the create update RPC will be sent during declare phase,
- * if creation reaches here, it means the object has been created
- * successfully */
- dt->do_lu.lo_header->loh_attr |= LOHA_EXISTS | (attr->la_mode & S_IFMT);
- dt2osp_obj(dt)->opo_non_exist = 0;
+ if (is_only_remote_trans(th)) {
+ rc = __osp_md_declare_object_create(env, dt, attr, hint,
+ dof, th);
- return 0;
+ CDEBUG(D_INFO, "create md_object "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ if (rc == 0) {
+ dt->do_lu.lo_header->loh_attr |= LOHA_EXISTS |
+ (attr->la_mode & S_IFMT);
+ dt2osp_obj(dt)->opo_non_exist = 0;
+ }
+
+ return rc;
}
/**
- * Implementation of dt_object_operations::do_declare_ref_del
- *
- * Declare decreasing the reference count of the remote object, i.e. insert
- * decreasing object reference count update into the RPC, which will be sent
- * during transaction start.
+ * Add OUT_REF_DEL sub-request into the OUT RPC.
*
* \param[in] env execution environment
* \param[in] dt object to decrease the reference count.
* \retval 0 if the insertion succeeds.
* \retval negative errno if the insertion fails.
*/
-static int osp_md_declare_object_ref_del(const struct lu_env *env,
- struct dt_object *dt,
- struct thandle *th)
+static int __osp_md_ref_del(const struct lu_env *env, struct dt_object *dt,
+ struct thandle *th)
{
struct dt_update_request *update;
int rc;
}
/**
+ * Implementation of dt_object_operations::do_declare_ref_del
+ *
+ * For non-remote transaction, it will add an OUT_REF_DEL sub-request
+ * into the OUT RPC that will be flushed when the transaction start.
+ *
+ * \param[in] env execution environment
+ * \param[in] dt object to decrease the reference count.
+ * \param[in] th the transaction handle of refcount decrease.
+ *
+ * \retval 0 if the insertion succeeds.
+ * \retval negative errno if the insertion fails.
+ */
+static int osp_md_declare_ref_del(const struct lu_env *env,
+ struct dt_object *dt, struct thandle *th)
+{
+ int rc = 0;
+
+ if (!is_only_remote_trans(th)) {
+ rc = __osp_md_ref_del(env, dt, th);
+
+ CDEBUG(D_INFO, "declare ref del "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
+}
+
+/**
* Implementation of dt_object_operations::do_ref_del
*
- * Do nothing in this method for now. In DNE phase I, remote updates are
- * actually executed during transaction start, i.e. the object reference
- * count has already been decreased when calling this method.
+ * For remote transaction, it will add an OUT_REF_DEL sub-request into
+ * the OUT RPC that will be flushed when the transaction stop.
*
* \param[in] env execution environment
* \param[in] dt object to decrease the reference count
*
* \retval only return 0 for now
*/
-static int osp_md_object_ref_del(const struct lu_env *env,
- struct dt_object *dt,
- struct thandle *th)
+static int osp_md_ref_del(const struct lu_env *env, struct dt_object *dt,
+ struct thandle *th)
{
- CDEBUG(D_INFO, "ref del object "DFID"\n",
- PFID(&dt->do_lu.lo_header->loh_fid));
+ int rc = 0;
- return 0;
+ if (is_only_remote_trans(th)) {
+ rc = __osp_md_ref_del(env, dt, th);
+
+ CDEBUG(D_INFO, "ref del "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
}
/**
- * Implementation of dt_object_operations::do_declare_ref_del
- *
- * Declare increasing the reference count of the remote object,
- * i.e. insert increasing object reference count update into RPC.
+ * Add OUT_REF_ADD sub-request into the OUT RPC.
*
* \param[in] env execution environment
* \param[in] dt object on which to increase the reference count.
* \retval 0 if the insertion succeeds.
* \retval negative errno if the insertion fails.
*/
-static int osp_md_declare_ref_add(const struct lu_env *env,
- struct dt_object *dt, struct thandle *th)
+static int __osp_md_ref_add(const struct lu_env *env, struct dt_object *dt,
+ struct thandle *th)
{
struct dt_update_request *update;
int rc;
}
/**
+ * Implementation of dt_object_operations::do_declare_ref_del
+ *
+ * For non-remote transaction, it will add an OUT_REF_ADD sub-request
+ * into the OUT RPC that will be flushed when the transaction start.
+ *
+ * \param[in] env execution environment
+ * \param[in] dt object on which to increase the reference count.
+ * \param[in] th the transaction handle.
+ *
+ * \retval 0 if the insertion succeeds.
+ * \retval negative errno if the insertion fails.
+ */
+static int osp_md_declare_ref_add(const struct lu_env *env,
+ struct dt_object *dt, struct thandle *th)
+{
+ int rc = 0;
+
+ if (!is_only_remote_trans(th)) {
+ rc = __osp_md_ref_add(env, dt, th);
+
+ CDEBUG(D_INFO, "declare ref add "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
+}
+
+/**
* Implementation of dt_object_operations::do_ref_add
*
- * Do nothing in this method for now. In DNE phase I, remote updates are
- * actually executed during transaction start, i.e. the object reference
- * count has already been increased when calling this method.
+ * For remote transaction, it will add an OUT_REF_ADD sub-request into
+ * the OUT RPC that will be flushed when the transaction stop.
*
* \param[in] env execution environment
* \param[in] dt object on which to increase the reference count
*
* \retval only return 0 for now
*/
-static int osp_md_object_ref_add(const struct lu_env *env, struct dt_object *dt,
- struct thandle *th)
+static int osp_md_ref_add(const struct lu_env *env, struct dt_object *dt,
+ struct thandle *th)
{
- CDEBUG(D_INFO, "ref add object "DFID"\n",
- PFID(&dt->do_lu.lo_header->loh_fid));
+ int rc = 0;
- return 0;
+ if (is_only_remote_trans(th)) {
+ rc = __osp_md_ref_add(env, dt, th);
+
+ CDEBUG(D_INFO, "ref add "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
}
/**
}
/**
- * Add attr_set sub-request into the OUT RPC.
+ * Add OUT_ATTR_SET sub-request into the OUT RPC.
*
* \param[in] env execution environment
* \param[in] dt object on which to set attributes
*
* Declare setting attributes to the specified remote object.
*
- * If the transaction is a remote transaction, then add the modification
- * sub-request into the OUT RPC here, and such OUT RPC will be triggered
- * when transaction start.
+ * If the transaction is a non-remote transaction, then add the OUT_ATTR_SET
+ * sub-request into the OUT RPC that will be flushed when the transaction start.
*
* \param[in] env execution environment
* \param[in] dt object on which to set attributes
{
int rc = 0;
- CDEBUG(D_INFO, "declare attr set object "DFID"\n",
- PFID(&dt->do_lu.lo_header->loh_fid));
-
- if (!is_only_remote_trans(th))
+ if (!is_only_remote_trans(th)) {
rc = __osp_md_attr_set(env, dt, attr, th);
+ CDEBUG(D_INFO, "declare attr set md_object "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
*
* Set attributes to the specified remote object.
*
- * If the transaction is a remote transaction, then related modification
- * sub-request has been added in the declare phase and related OUT RPC
- * has been triggered at transaction start. Otherwise, the modification
- * sub-request will be added here, and related OUT RPC will be triggered
- * when transaction stop.
+ * If the transaction is a remote transaction, then add the OUT_ATTR_SET
+ * sub-request into the OUT RPC that will be flushed when the transaction stop.
*
* \param[in] env execution environment
* \param[in] dt object to set attributes
{
int rc = 0;
- CDEBUG(D_INFO, "attr set object "DFID"\n",
- PFID(&dt->do_lu.lo_header->loh_fid));
-
- if (is_only_remote_trans(th))
+ if (is_only_remote_trans(th)) {
rc = __osp_md_attr_set(env, dt, attr, th);
- RETURN(rc);
+ CDEBUG(D_INFO, "attr set md_object "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
+ return rc;
}
/**
}
/**
- * Implementation of dt_index_operations::dio_declare_insert
- *
- * Declare the index insert of the remote object, i.e. pack index insert update
- * into the RPC, which will be sent during transaction start.
+ * Add OUT_INDEX_INSERT sub-request into the OUT RPC.
*
* \param[in] env execution environment
* \param[in] dt object for which to insert index
* \retval 0 if the insertion succeeds.
* \retval negative errno if the insertion fails.
*/
-static int osp_md_declare_insert(const struct lu_env *env,
+static int __osp_md_index_insert(const struct lu_env *env,
struct dt_object *dt,
const struct dt_rec *rec,
const struct dt_key *key,
}
/**
+ * Implementation of dt_index_operations::dio_declare_insert
+ *
+ * For non-remote transaction, it will add an OUT_INDEX_INSERT sub-request
+ * into the OUT RPC that will be flushed when the transaction start.
+ *
+ * \param[in] env execution environment
+ * \param[in] dt object for which to insert index
+ * \param[in] rec record of the index which will be inserted
+ * \param[in] key key of the index which will be inserted
+ * \param[in] th the transaction handle
+ *
+ * \retval 0 if the insertion succeeds.
+ * \retval negative errno if the insertion fails.
+ */
+static int osp_md_declare_index_insert(const struct lu_env *env,
+ struct dt_object *dt,
+ const struct dt_rec *rec,
+ const struct dt_key *key,
+ struct thandle *th)
+{
+ int rc = 0;
+
+ if (!is_only_remote_trans(th)) {
+ rc = __osp_md_index_insert(env, dt, rec, key, th);
+
+ CDEBUG(D_INFO, "declare index insert "DFID" key %s, rec "DFID
+ ": rc = %d\n", PFID(&dt->do_lu.lo_header->loh_fid),
+ (char *)key,
+ PFID(((struct dt_insert_rec *)rec)->rec_fid), rc);
+ }
+
+ return rc;
+}
+
+/**
* Implementation of dt_index_operations::dio_insert
*
- * Do nothing in this method for now. In DNE phase I, remote updates
- * are actually executed during transaction start, i.e. the index has
- * already been inserted when calling this method.
+ * For remote transaction, it will add an OUT_INDEX_INSERT sub-request
+ * into the OUT RPC that will be flushed when the transaction stop.
*
* \param[in] env execution environment
* \param[in] dt object for which to insert index
struct lustre_capa *capa,
int ignore_quota)
{
- return 0;
+ int rc = 0;
+
+ if (is_only_remote_trans(th)) {
+ rc = __osp_md_index_insert(env, dt, rec, key, th);
+
+ CDEBUG(D_INFO, "index insert "DFID" key %s, rec "DFID
+ ": rc = %d\n", PFID(&dt->do_lu.lo_header->loh_fid),
+ (char *)key,
+ PFID(((struct dt_insert_rec *)rec)->rec_fid), rc);
+ }
+
+ return rc;
}
/**
- * Implementation of dt_index_operations::dio_declare_delete
- *
- * Declare the index delete of the remote object, i.e. insert index delete
- * update into the RPC, which will be sent during transaction start.
+ * Add OUT_INDEX_DELETE sub-request into the OUT RPC.
*
* \param[in] env execution environment
* \param[in] dt object for which to delete index
* \retval 0 if the insertion succeeds.
* \retval negative errno if the insertion fails.
*/
-static int osp_md_declare_delete(const struct lu_env *env,
+static int __osp_md_index_delete(const struct lu_env *env,
struct dt_object *dt,
const struct dt_key *key,
struct thandle *th)
}
/**
+ * Implementation of dt_index_operations::dio_declare_delete
+ *
+ * For non-remote transaction, it will add an OUT_INDEX_DELETE sub-request
+ * into the OUT RPC that will be flushed when the transaction start.
+ *
+ * \param[in] env execution environment
+ * \param[in] dt object for which to delete index
+ * \param[in] key key of the index
+ * \param[in] th the transaction handle
+ *
+ * \retval 0 if the insertion succeeds.
+ * \retval negative errno if the insertion fails.
+ */
+static int osp_md_declare_index_delete(const struct lu_env *env,
+ struct dt_object *dt,
+ const struct dt_key *key,
+ struct thandle *th)
+{
+ int rc = 0;
+
+ if (!is_only_remote_trans(th)) {
+ rc = __osp_md_index_delete(env, dt, key, th);
+
+ CDEBUG(D_INFO, "declare index delete "DFID" %s: rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), (char *)key, rc);
+ }
+
+ return rc;
+}
+
+/**
* Implementation of dt_index_operations::dio_delete
*
- * Do nothing in this method for now. Because in DNE phase I, remote updates
- * are actually executed during transaction start, i.e. the index has already
- * been deleted when calling this method.
+ * For remote transaction, it will add an OUT_INDEX_DELETE sub-request
+ * into the OUT RPC that will be flushed when the transaction stop.
*
* \param[in] env execution environment
* \param[in] dt object for which to delete index
struct thandle *th,
struct lustre_capa *capa)
{
- CDEBUG(D_INFO, "index delete "DFID" %s\n",
- PFID(&dt->do_lu.lo_header->loh_fid), (char *)key);
+ int rc = 0;
- return 0;
+ if (is_only_remote_trans(th)) {
+ rc = __osp_md_index_delete(env, dt, key, th);
+
+ CDEBUG(D_INFO, "index delete "DFID" %s: rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), (char *)key, rc);
+ }
+
+ return rc;
}
/**
const struct dt_index_operations osp_md_index_ops = {
.dio_lookup = osp_md_index_lookup,
- .dio_declare_insert = osp_md_declare_insert,
+ .dio_declare_insert = osp_md_declare_index_insert,
.dio_insert = osp_md_index_insert,
- .dio_declare_delete = osp_md_declare_delete,
+ .dio_declare_delete = osp_md_declare_index_delete,
.dio_delete = osp_md_index_delete,
.dio_it = {
.init = osp_it_init,
.do_declare_create = osp_md_declare_object_create,
.do_create = osp_md_object_create,
.do_declare_ref_add = osp_md_declare_ref_add,
- .do_ref_add = osp_md_object_ref_add,
- .do_declare_ref_del = osp_md_declare_object_ref_del,
- .do_ref_del = osp_md_object_ref_del,
+ .do_ref_add = osp_md_ref_add,
+ .do_declare_ref_del = osp_md_declare_ref_del,
+ .do_ref_del = osp_md_ref_del,
.do_declare_destroy = osp_declare_object_destroy,
.do_destroy = osp_object_destroy,
.do_ah_init = osp_md_ah_init,
* or osp_declare_xattr_get(). That is usually for LFSCK purpose,
* but it also can be shared by others.
*
+ *
+ * XXX: NOT prepare out RPC for remote transaction. ((please refer to the
+ * comment of osp_trans_create() for remote transaction)
+ *
+ * According to our current transaction/dt_object_lock framework (to make
+ * the cross-MDTs modification for DNE1 to be workable), the transaction
+ * sponsor will start the transaction firstly, then try to acquire related
+ * dt_object_lock if needed. Under such rules, if we want to prepare the
+ * OUT RPC in the transaction declare phase, then related attr/xattr
+ * should be known without dt_object_lock. But such condition maybe not
+ * true for some remote transaction case. For example:
+ *
+ * For linkEA repairing (by LFSCK) case, before the LFSCK thread obtained
+ * the dt_object_lock on the target MDT-object, it cannot know whether
+ * the MDT-object has linkEA or not, neither invalid or not.
+ *
+ * Since the LFSCK thread cannot hold dt_object_lock before the remote
+ * transaction start (otherwise there will be some potential deadlock),
+ * it cannot prepare related OUT RPC for repairing during the declare
+ * phase as other normal transactions do.
+ *
+ * To resolve the trouble, we will make OSP to prepare related OUT RPC
+ * after remote transaction started, and trigger the remote updating
+ * (send RPC) when trans_stop. Then the up layer users, such as LFSCK,
+ * can follow the general rule to handle trans_start/dt_object_lock
+ * for repairing linkEA inconsistency without distinguishing remote
+ * MDT-object.
+ *
+ * In fact, above solution for remote transaction should be the normal
+ * model without considering DNE1. The trouble brought by DNE1 will be
+ * resolved in DNE2. At that time, this patch can be removed.
+ *
+ *
* Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
* Author: Mikhail Pershin <mike.tappro@intel.com>
*/
/**
* Implement OSP layer dt_object_operations::do_declare_attr_set() interface.
- * XXX: NOT prepare set_{attr,xattr} RPC for remote transaction.
- *
- * According to our current transaction/dt_object_lock framework (to make
- * the cross-MDTs modification for DNE1 to be workable), the transaction
- * sponsor will start the transaction firstly, then try to acquire related
- * dt_object_lock if needed. Under such rules, if we want to prepare the
- * set_{attr,xattr} RPC in the RPC declare phase, then related attr/xattr
- * should be known without dt_object_lock. But such condition maybe not
- * true for some remote transaction case. For example:
*
- * For linkEA repairing (by LFSCK) case, before the LFSCK thread obtained
- * the dt_object_lock on the target MDT-object, it cannot know whether
- * the MDT-object has linkEA or not, neither invalid or not.
- *
- * Since the LFSCK thread cannot hold dt_object_lock before the (remote)
- * transaction start (otherwise there will be some potential deadlock),
- * it cannot prepare related RPC for repairing during the declare phase
- * as other normal transactions do.
- *
- * To resolve the trouble, we will make OSP to prepare related RPC
- * (set_attr/set_xattr/del_xattr) after remote transaction started,
- * and trigger the remote updating (RPC sending) when trans_stop.
- * Then the up layer users, such as LFSCK, can follow the general
- * rule to handle trans_start/dt_object_lock for repairing linkEA
- * inconsistency without distinguishing remote MDT-object.
- *
- * In fact, above solution for remote transaction should be the normal
- * model without considering DNE1. The trouble brought by DNE1 will be
- * resolved in DNE2. At that time, this patch can be removed.
+ * If the transaction is not remote one, then declare the credits that will
+ * be used for the subsequent llog record for the object's attributes.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
{
int rc = 0;
- if (!is_only_remote_trans(th))
+ if (!is_only_remote_trans(th)) {
rc = __osp_attr_set(env, dt, attr, th);
+ CDEBUG(D_INFO, "declare set attr "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
*
* Set attribute to the specified OST object.
*
- * If the transaction is a remote transaction, then related modification
- * sub-request has been added in the declare phase and related OUT RPC
- * has been triggered at transaction start. Otherwise it will generate
- * a MDS_SETATTR64_REC record in the llog. There is a dedicated thread
- * to handle the llog asynchronously.
+ * If the transaction is a remote one, then add OUT_ATTR_SET sub-request
+ * in the OUT RPC that will be flushed when the remote transaction stop.
+ * Otherwise, it will generate a MDS_SETATTR64_REC record in the llog that
+ * will be handled by a dedicated thread asynchronously.
*
* If the attribute entry exists in the OSP object attributes cache,
* then update the cached attribute according to given attribute.
if (is_only_remote_trans(th)) {
rc = __osp_attr_set(env, dt, attr, th);
+
+ CDEBUG(D_INFO, "(1) set attr "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+
RETURN(rc);
}
rc = osp_sync_add(env, o, MDS_SETATTR64_REC, th, attr);
/* XXX: send new uid/gid to OST ASAP? */
+ CDEBUG(D_INFO, "(2) set attr "DFID": rc = %d\n",
+ PFID(&dt->do_lu.lo_header->loh_fid), rc);
+
RETURN(rc);
}
* Declare that the caller will set extended attribute to the specified
* MDT/OST object.
*
- * This function will add an OUT_XATTR_SET sub-request to the per
- * OSP-transaction based request queue which will be flushed when
- * the transaction starts.
+ * If it is non-remote transaction, it will add an OUT_XATTR_SET sub-request
+ * to the OUT RPC that will be flushed when the transaction start. And if the
+ * OSP attributes cache is initialized, then check whether the name extended
+ * attribute entry exists in the cache or not. If yes, replace it; otherwise,
+ * add the extended attribute to the cache.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
{
int rc = 0;
- /* Please check the comment in osp_attr_set() for handling
- * remote transaction. */
- if (!is_only_remote_trans(th))
+ if (!is_only_remote_trans(th)) {
rc = __osp_xattr_set(env, dt, buf, name, flag, th);
+ CDEBUG(D_INFO, "declare xattr %s set object "DFID": rc = %d\n",
+ name, PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
*
* Set extended attribute to the specified MDT/OST object.
*
- * The real modification sub-request has been added in the declare phase
- * and related (OUT) RPC has been triggered when transaction start.
- *
- * If the OSP attributes cache is initialized, then check whether the name
- * extended attribute entry exists in the cache or not. If yes, replace it;
- * otherwise, add the extended attribute to the cache.
+ * If it is remote transaction, it will add an OUT_XATTR_SET sub-request into
+ * the OUT RPC that will be flushed when the transaction stop. And if the OSP
+ * attributes cache is initialized, then check whether the name extended
+ * attribute entry exists in the cache or not. If yes, replace it; otherwise,
+ * add the extended attribute to the cache.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
{
int rc = 0;
- CDEBUG(D_INFO, "xattr %s set object "DFID"\n", name,
- PFID(&dt->do_lu.lo_header->loh_fid));
-
- /* Please check the comment in osp_attr_set() for handling
- * remote transaction. */
- if (is_only_remote_trans(th))
+ if (is_only_remote_trans(th)) {
rc = __osp_xattr_set(env, dt, buf, name, fl, th);
+ CDEBUG(D_INFO, "xattr %s set object "DFID": rc = %d\n",
+ name, PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
* Declare that the caller will delete extended attribute on the specified
* MDT/OST object.
*
- * This function will add an OUT_XATTR_DEL sub-request to the per
- * OSP-transaction based request queue which will be flushed when
- * transaction start.
+ * If it is non-remote transaction, it will add an OUT_XATTR_DEL sub-request
+ * to the OUT RPC that will be flushed when the transaction start. And if the
+ * name extended attribute entry exists in the OSP attributes cache, then remove
+ * it from the cache.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
{
int rc = 0;
- /* Please check the comment in osp_attr_set() for handling
- * remote transaction. */
- if (!is_only_remote_trans(th))
+ if (!is_only_remote_trans(th)) {
rc = __osp_xattr_del(env, dt, name, th);
+ CDEBUG(D_INFO, "declare xattr %s del object "DFID": rc = %d\n",
+ name, PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
*
* Delete extended attribute on the specified MDT/OST object.
*
- * The real modification sub-request has been added in the declare phase
- * and related (OUT) RPC has been triggered when transaction start.
- *
- * If the name extended attribute entry exists in the OSP attributes
- * cache, then remove it from the cache.
+ * If it is remote transaction, it will add an OUT_XATTR_DEL sub-request into
+ * the OUT RPC that will be flushed when the transaction stop. And if the name
+ * extended attribute entry exists in the OSP attributes cache, then remove it
+ * from the cache.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
{
int rc = 0;
- CDEBUG(D_INFO, "xattr %s del object "DFID"\n", name,
- PFID(&dt->do_lu.lo_header->loh_fid));
-
- /* Please check the comment in osp_attr_set() for handling
- * remote transaction. */
- if (is_only_remote_trans(th))
+ if (is_only_remote_trans(th)) {
rc = __osp_xattr_del(env, dt, name, th);
+ CDEBUG(D_INFO, "xattr %s del object "DFID": rc = %d\n",
+ name, PFID(&dt->do_lu.lo_header->loh_fid), rc);
+ }
+
return rc;
}
*
* Declare that the caller will create the OST object.
*
- * If the transaction is a remote transaction (please refer to the
- * comment of osp_trans_create() for remote transaction), then the FID
- * for the OST object has been assigned already, and will be handled
- * as create (remote) MDT object via osp_md_declare_object_create().
- * This function is usually used for LFSCK to re-create the lost OST
- * object. Otherwise, if it is not replay case, the OSP will reserve
- * pre-created object for the subsequent create operation; if the MDT
- * side cached pre-created objects are less than some threshold, then
- * it will wakeup the pre-create thread.
+ * If the transaction is a remote transaction and the FID for the OST-object
+ * has been assigned already, then handle it as creating (remote) MDT object
+ * via osp_md_declare_object_create(). This function is usually used for LFSCK
+ * to re-create the lost OST object. Otherwise, if it is not replay case, the
+ * OSP will reserve pre-created object for the subsequent create operation;
+ * if the MDT side cached pre-created objects are less than some threshold,
+ * then it will wakeup the pre-create thread.
*
* \param[in] env pointer to the thread context
* \param[in] dt pointer to the OSP layer dt_object
ENTRY;
- if (is_only_remote_trans(th)) {
+ if (is_only_remote_trans(th) && !fid_is_zero(fid)) {
LASSERT(fid_is_sane(fid));
rc = osp_md_declare_object_create(env, dt, attr, hint, dof, th);
*
* Create the OST object.
*
- * For remote transaction case, the real create sub-request has been
- * added in the declare phase and related (OUT) RPC has been triggered
- * at transaction start. Here, like creating (remote) MDT object, the
- * OSP will mark the object existence via osp_md_object_create().
- *
- * For non-remote transaction case, the OSP will assign FID to the
+ * If the transaction is a remote transaction and the FID for the OST-object
+ * has been assigned already, then handle it as handling MDT object via the
+ * osp_md_object_create(). For other cases, the OSP will assign FID to the
* object to be created, and update last_used Object ID (OID) file.
*
* \param[in] env pointer to the thread context
struct lu_fid *fid = &osi->osi_fid;
ENTRY;
- if (is_only_remote_trans(th)) {
+ if (is_only_remote_trans(th) &&
+ !fid_is_zero(lu_object_fid(&dt->do_lu))) {
LASSERT(fid_is_sane(lu_object_fid(&dt->do_lu)));
rc = osp_md_object_create(env, dt, attr, hint, dof, th);