int osc_quota_setdq(struct client_obd *cli, const unsigned int qid[],
u64 valid, u32 flags)
{
int type;
int rc = 0;
ENTRY;
if ((valid & (OBD_MD_FLALLQUOTA)) == 0)
RETURN(0);
for (type = 0; type < LL_MAXQUOTAS; type++) {
struct osc_quota_info *oqi;
if ((valid & md_quota_flag(type)) == 0)
continue;
/* lookup the ID in the per-type hash table */
oqi = cfs_hash_lookup(cli->cl_quota_hash[type], &qid[type]);
if ((flags & fl_quota_flag(type)) != 0) {
/* This ID is getting close to its quota limit, let's
* switch to sync I/O */
if (oqi != NULL)
continue;
oqi = osc_oqi_alloc(qid[type]);
if (oqi == NULL) {
rc = -ENOMEM;
break;
}
rc = cfs_hash_add_unique(cli->cl_quota_hash[type],
&qid[type], &oqi->oqi_hash);
/* race with others? */
if (rc == -EALREADY) {
rc = 0;
OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
}
CDEBUG(D_QUOTA, "%s: setdq to insert for %s %d (%d)\n",
cli_name(cli), qtype_name(type), qid[type], rc);
} else {
/* This ID is now off the hook, let's remove it from
* the hash table */
if (oqi == NULL)
continue;
oqi = cfs_hash_del_key(cli->cl_quota_hash[type],
&qid[type]);
if (oqi)
OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
CDEBUG(D_QUOTA, "%s: setdq to remove for %s %d (%p)\n",
cli_name(cli), qtype_name(type), qid[type], oqi);
}
}
RETURN(rc);
}
static void osc_object_free(const struct lu_env *env, struct lu_object *obj)
{
struct osc_object *osc = lu2osc(obj);
int i;
for (i = 0; i < CRT_NR; ++i)
LASSERT(list_empty(&osc->oo_inflight[i]));
LASSERT(list_empty(&osc->oo_ready_item));
LASSERT(list_empty(&osc->oo_hp_ready_item));
LASSERT(list_empty(&osc->oo_write_item));
LASSERT(list_empty(&osc->oo_read_item));
LASSERT(osc->oo_root.rb_node == NULL);
LASSERT(list_empty(&osc->oo_hp_exts));
LASSERT(list_empty(&osc->oo_urgent_exts));
LASSERT(list_empty(&osc->oo_rpc_exts));
LASSERT(list_empty(&osc->oo_reading_exts));
LASSERT(atomic_read(&osc->oo_nr_reads) == 0);
LASSERT(atomic_read(&osc->oo_nr_writes) == 0);
LASSERT(list_empty(&osc->oo_ol_list));
lu_object_fini(obj);
OBD_SLAB_FREE_PTR(osc, osc_object_kmem);
}
static void lov_key_fini(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
struct lov_thread_info *info = data;
LINVRNT(list_empty(&info->lti_closure.clc_list));
OBD_SLAB_FREE_PTR(info, lov_thread_kmem);
}
static void osc_req_completion(const struct lu_env *env,
const struct cl_req_slice *slice, int ioret)
{
struct osc_req *or;
or = cl2osc_req(slice);
OBD_SLAB_FREE_PTR(or, osc_req_kmem);
}
static void lov_object_free(const struct lu_env *env, struct lu_object *obj)
{
struct lov_object *lov = lu2lov(obj);
LOV_2DISPATCH_VOID(lov, llo_fini, env, lov, &lov->u);
lu_object_fini(obj);
OBD_SLAB_FREE_PTR(lov, lov_object_kmem);
}
static void lovsub_req_completion(const struct lu_env *env,
const struct cl_req_slice *slice, int ioret)
{
struct lovsub_req *lsr;
lsr = cl2lovsub_req(slice);
OBD_SLAB_FREE_PTR(lsr, lovsub_req_kmem);
}
static void vvp_object_free(const struct lu_env *env, struct lu_object *obj)
{
struct vvp_object *vob = lu2vvp(obj);
lu_object_fini(obj);
lu_object_header_fini(obj->lo_header);
OBD_SLAB_FREE_PTR(vob, vvp_object_kmem);
}
void osc_lock_fini(const struct lu_env *env, struct cl_lock_slice *slice)
{
struct osc_lock *ols = cl2osc_lock(slice);
LINVRNT(osc_lock_invariant(ols));
LASSERT(ols->ols_dlmlock == NULL);
OBD_SLAB_FREE_PTR(ols, osc_lock_kmem);
}
static void osp_object_free(const struct lu_env *env, struct lu_object *o)
{
struct osp_object *obj = lu2osp_obj(o);
struct lu_object_header *h = o->lo_header;
dt_object_fini(&obj->opo_obj);
lu_object_header_fini(h);
OBD_SLAB_FREE_PTR(obj, osp_object_kmem);
}
static void
oqi_exit(struct cfs_hash *hs, struct hlist_node *hnode)
{
struct osc_quota_info *oqi;
oqi = hlist_entry(hnode, struct osc_quota_info, oqi_hash);
OBD_SLAB_FREE_PTR(oqi, osc_quota_kmem);
}
/*
* Concurrency: no concurrent access is possible that late in object
* life-cycle.
*/
static void osd_object_free(const struct lu_env *env, struct lu_object *l)
{
struct osd_object *obj = osd_obj(l);
LASSERT(osd_invariant(obj));
dt_object_fini(&obj->oo_dt);
OBD_SLAB_FREE_PTR(obj, osd_object_kmem);
}
static void lovsub_lock_fini(const struct lu_env *env,
struct cl_lock_slice *slice)
{
struct lovsub_lock *lsl;
ENTRY;
lsl = cl2lovsub_lock(slice);
LASSERT(list_empty(&lsl->lss_parents));
OBD_SLAB_FREE_PTR(lsl, lovsub_lock_kmem);
EXIT;
}
static void osc_lock_fini(const struct lu_env *env,
struct cl_lock_slice *slice)
{
struct osc_lock *ols = cl2osc_lock(slice);
LINVRNT(osc_lock_invariant(ols));
/*
* ->ols_hold can still be true at this point if, for example, a
* thread that requested a lock was killed (and released a reference
* to the lock), before reply from a server was received. In this case
* lock is destroyed immediately after upcall.
*/
osc_lock_unhold(ols);
LASSERT(ols->ols_lock == NULL);
LASSERT(atomic_read(&ols->ols_pageref) == 0 ||
atomic_read(&ols->ols_pageref) == _PAGEREF_MAGIC);
OBD_SLAB_FREE_PTR(ols, osc_lock_kmem);
}
static void lovsub_object_free(const struct lu_env *env, struct lu_object *obj)
{
struct lovsub_object *los = lu2lovsub(obj);
struct lov_object *lov = los->lso_super;
/* We can't assume lov was assigned here, because of the shadow
* object handling in lu_object_find.
*/
if (lov) {
LASSERT(lov->lo_type == LLT_RAID0);
LASSERT(lov->u.raid0.lo_sub[los->lso_index] == los);
spin_lock(&lov->u.raid0.lo_sub_lock);
lov->u.raid0.lo_sub[los->lso_index] = NULL;
spin_unlock(&lov->u.raid0.lo_sub_lock);
}
lu_object_fini(obj);
lu_object_header_fini(&los->lso_header.coh_lu);
OBD_SLAB_FREE_PTR(los, lovsub_object_kmem);
}
static void osc_session_fini(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
struct osc_session *info = data;
OBD_SLAB_FREE_PTR(info, osc_session_kmem);
}
static void ll_destroy_inode(struct inode *inode)
{
struct ll_inode_info *ptr = ll_i2info(inode);
OBD_SLAB_FREE_PTR(ptr, ll_inode_cachep);
}
static void vvp_key_fini(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
struct vvp_thread_info *info = data;
OBD_SLAB_FREE_PTR(info, vvp_thread_kmem);
}
static void vvp_session_key_fini(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
struct vvp_session *session = data;
OBD_SLAB_FREE_PTR(session, vvp_session_kmem);
}
static void ll_inode_destroy_callback(struct rcu_head *head)
{
struct inode *inode = container_of(head, struct inode, i_rcu);
struct ll_inode_info *ptr = ll_i2info(inode);
OBD_SLAB_FREE_PTR(ptr, ll_inode_cachep);
}
static void vvp_lock_fini(const struct lu_env *env, struct cl_lock_slice *slice)
{
struct vvp_lock *vlk = cl2vvp_lock(slice);
OBD_SLAB_FREE_PTR(vlk, vvp_lock_kmem);
}