void
dt_destroy(struct decision *dec)
{
if (dec->dest != NULL)
dt_destroy(dec->dest);
if (dec->next != NULL)
dt_destroy(dec->next);
free(dec);
}
static int out_obj_destroy(const struct lu_env *env, struct dt_object *dt_obj,
struct thandle *th)
{
int rc;
CDEBUG(D_INFO, "%s: destroy "DFID"\n", dt_obd_name(th->th_dev),
PFID(lu_object_fid(&dt_obj->do_lu)));
dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
rc = dt_destroy(env, dt_obj, th);
dt_write_unlock(env, dt_obj);
return rc;
}
/**
* All of the xxx_undo will be used once execution failed,
* But because all of the required resource has been reserved in
* declare phase, i.e. if declare succeed, it should make sure
* the following executing phase succeed in anyway, so these undo
* should be useless for most of the time in Phase I
**/
int out_tx_create_undo(struct mdt_thread_info *info, struct thandle *th,
struct tx_arg *arg)
{
struct dt_object *dt_obj = arg->object;
int rc;
LASSERT(dt_obj != NULL && !IS_ERR(dt_obj));
dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD);
rc = dt_destroy(info->mti_env, dt_obj, th);
dt_write_unlock(info->mti_env, dt_obj);
/* we don't like double failures */
if (rc != 0)
CERROR("%s: undo failure, we are doomed!: rc = %d\n",
mdt_obd_name(info->mti_mdt), rc);
return rc;
}
int ofd_object_destroy(const struct lu_env *env, struct ofd_object *fo,
int orphan)
{
struct ofd_device *ofd = ofd_obj2dev(fo);
struct thandle *th;
int rc = 0;
ENTRY;
ofd_write_lock(env, fo);
if (!ofd_object_exists(fo))
GOTO(unlock, rc = -ENOENT);
th = ofd_trans_create(env, ofd);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
dt_declare_ref_del(env, ofd_object_child(fo), th);
dt_declare_destroy(env, ofd_object_child(fo), th);
if (orphan)
rc = dt_trans_start_local(env, ofd->ofd_osd, th);
else
rc = ofd_trans_start(env, ofd, NULL, th);
if (rc)
GOTO(stop, rc);
ofd_fmd_drop(ofd_info(env)->fti_exp, &fo->ofo_header.loh_fid);
dt_ref_del(env, ofd_object_child(fo), th);
dt_destroy(env, ofd_object_child(fo), th);
stop:
ofd_trans_stop(env, ofd, th, rc);
unlock:
ofd_write_unlock(env, fo);
RETURN(rc);
}
/**
* Implementation of the llog_operations::lop_destroy
*
* This function destroys the llog and deletes also entry in the
* llog directory in case of named llog. Llog should be opened prior that.
* Destroy method is not part of external transaction and does everything
* inside.
*
* \param[in] env execution environment
* \param[in] loghandle llog handle of the current llog
*
* \retval 0 on successful destroy
* \retval negative value on error
*/
static int llog_osd_destroy(const struct lu_env *env,
struct llog_handle *loghandle)
{
struct llog_ctxt *ctxt;
struct dt_object *o, *llog_dir = NULL;
struct dt_device *d;
struct thandle *th;
char *name = NULL;
int rc;
ENTRY;
ctxt = loghandle->lgh_ctxt;
LASSERT(ctxt);
o = loghandle->lgh_obj;
LASSERT(o);
d = lu2dt_dev(o->do_lu.lo_dev);
LASSERT(d);
LASSERT(d == ctxt->loc_exp->exp_obd->obd_lvfs_ctxt.dt);
th = dt_trans_create(env, d);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
if (loghandle->lgh_name) {
llog_dir = llog_osd_dir_get(env, ctxt);
if (IS_ERR(llog_dir))
GOTO(out_trans, rc = PTR_ERR(llog_dir));
name = loghandle->lgh_name;
rc = dt_declare_delete(env, llog_dir,
(struct dt_key *)name, th);
if (rc)
GOTO(out_trans, rc);
}
dt_declare_ref_del(env, o, th);
rc = dt_declare_destroy(env, o, th);
if (rc)
GOTO(out_trans, rc);
rc = dt_trans_start_local(env, d, th);
if (rc)
GOTO(out_trans, rc);
dt_write_lock(env, o, 0);
if (dt_object_exists(o)) {
if (name) {
dt_read_lock(env, llog_dir, 0);
rc = dt_delete(env, llog_dir,
(struct dt_key *) name,
th, BYPASS_CAPA);
dt_read_unlock(env, llog_dir);
if (rc) {
CERROR("%s: can't remove llog %s: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
name, rc);
GOTO(out_unlock, rc);
}
}
dt_ref_del(env, o, th);
rc = dt_destroy(env, o, th);
if (rc)
GOTO(out_unlock, rc);
}
out_unlock:
dt_write_unlock(env, o);
out_trans:
dt_trans_stop(env, d, th);
if (llog_dir != NULL)
lu_object_put(env, &llog_dir->do_lu);
RETURN(rc);
}
static int llog_osd_destroy(const struct lu_env *env,
struct llog_handle *loghandle)
{
struct llog_thread_info *lgi = llog_info(env);
struct llog_ctxt *ctxt;
struct dt_object *o, *llog_dir = NULL;
struct dt_device *d;
struct thandle *th;
char *name = NULL;
int rc;
ENTRY;
ctxt = loghandle->lgh_ctxt;
LASSERT(ctxt);
o = loghandle->lgh_obj;
LASSERT(o);
d = lu2dt_dev(o->do_lu.lo_dev);
LASSERT(d);
LASSERT(d == ctxt->loc_exp->exp_obd->obd_lvfs_ctxt.dt);
th = dt_trans_create(env, d);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
if (loghandle->lgh_name) {
llog_dir = llog_osd_dir_get(env, ctxt);
if (IS_ERR(llog_dir))
GOTO(out_trans, rc = PTR_ERR(llog_dir));
dt_declare_ref_del(env, o, th);
name = loghandle->lgh_name;
rc = dt_declare_delete(env, llog_dir,
(struct dt_key *)name, th);
if (rc)
GOTO(out_trans, rc);
}
dt_declare_ref_del(env, o, th);
rc = dt_declare_destroy(env, o, th);
if (rc)
GOTO(out_trans, rc);
rc = dt_trans_start_local(env, d, th);
if (rc)
GOTO(out_trans, rc);
dt_write_lock(env, o, 0);
if (dt_object_exists(o)) {
if (name) {
dt_ref_del(env, o, th);
dt_read_lock(env, llog_dir, 0);
rc = dt_delete(env, llog_dir,
(struct dt_key *) name,
th, BYPASS_CAPA);
dt_read_unlock(env, llog_dir);
if (rc) {
CERROR("%s: can't remove llog %s: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
name, rc);
GOTO(out_unlock, rc);
}
}
/*
* XXX: compatibility bits
* on old filesystems llogs are referenced by the name
* on the new ones they are referenced by OI and by
* the name
*/
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
GOTO(out_unlock, rc);
LASSERT(lgi->lgi_attr.la_nlink < 2);
if (lgi->lgi_attr.la_nlink == 1)
dt_ref_del(env, o, th);
rc = dt_destroy(env, o, th);
if (rc)
GOTO(out_unlock, rc);
}
out_unlock:
dt_write_unlock(env, o);
out_trans:
dt_trans_stop(env, d, th);
if (llog_dir != NULL)
lu_object_put(env, &llog_dir->do_lu);
RETURN(rc);
}