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);
}
struct ptlrpc_connection *
ptlrpc_connection_get(struct lnet_process_id peer, lnet_nid_t self,
struct obd_uuid *uuid)
{
struct ptlrpc_connection *conn, *conn2;
ENTRY;
peer.nid = LNetPrimaryNID(peer.nid);
conn = cfs_hash_lookup(conn_hash, &peer);
if (conn)
GOTO(out, conn);
OBD_ALLOC_PTR(conn);
if (!conn)
RETURN(NULL);
conn->c_peer = peer;
conn->c_self = self;
INIT_HLIST_NODE(&conn->c_hash);
atomic_set(&conn->c_refcount, 1);
if (uuid)
obd_str2uuid(&conn->c_remote_uuid, uuid->uuid);
/*
* Add the newly created conn to the hash, on key collision we
* lost a racing addition and must destroy our newly allocated
* connection. The object which exists in the hash will be
* returned and may be compared against out object.
*/
/* In the function below, .hs_keycmp resolves to
* conn_keycmp() */
/* coverity[overrun-buffer-val] */
conn2 = cfs_hash_findadd_unique(conn_hash, &peer, &conn->c_hash);
if (conn != conn2) {
OBD_FREE_PTR(conn);
conn = conn2;
}
EXIT;
out:
CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
conn, atomic_read(&conn->c_refcount),
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
struct ptlrpc_connection *
ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self,
struct obd_uuid *uuid)
{
struct ptlrpc_connection *conn, *conn2;
conn = cfs_hash_lookup(conn_hash, &peer);
if (conn)
goto out;
conn = kzalloc(sizeof(*conn), GFP_NOFS);
if (!conn)
return NULL;
conn->c_peer = peer;
conn->c_self = self;
INIT_HLIST_NODE(&conn->c_hash);
atomic_set(&conn->c_refcount, 1);
if (uuid)
obd_str2uuid(&conn->c_remote_uuid, uuid->uuid);
/*
* Add the newly created conn to the hash, on key collision we
* lost a racing addition and must destroy our newly allocated
* connection. The object which exists in the has will be
* returned and may be compared against out object.
*/
/* In the function below, .hs_keycmp resolves to
* conn_keycmp()
*/
/* coverity[overrun-buffer-val] */
conn2 = cfs_hash_findadd_unique(conn_hash, &peer, &conn->c_hash);
if (conn != conn2) {
kfree(conn);
conn = conn2;
}
out:
CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
conn, atomic_read(&conn->c_refcount),
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
struct lustre_qunit_size *quota_search_lqs(unsigned long long lqs_key,
struct lustre_quota_ctxt *qctxt,
int create)
{
struct lustre_qunit_size *lqs;
int rc = 0;
search_lqs:
lqs = cfs_hash_lookup(qctxt->lqc_lqs_hash, &lqs_key);
if (IS_ERR(lqs))
GOTO(out, rc = PTR_ERR(lqs));
if (create && lqs == NULL) {
/* if quota_create_lqs is successful, it will get a
* ref to the lqs. The ref will be released when
* qctxt_cleanup() or quota is nullified */
lqs = quota_create_lqs(lqs_key, qctxt);
if (IS_ERR(lqs))
rc = PTR_ERR(lqs);
if (rc == -EALREADY)
GOTO(search_lqs, rc = 0);
/* get a reference for the caller when creating lqs
* successfully */
if (rc == 0)
lqs_getref(lqs);
}
if (lqs && rc == 0)
LQS_DEBUG(lqs, "%s\n",
(create == 1 ? "create lqs" : "search lqs"));
out:
if (rc == 0) {
return lqs;
} else {
CERROR("get lqs error(rc: %d)\n", rc);
return ERR_PTR(rc);
}
}
int osc_quota_chkdq(struct client_obd *cli, const unsigned int qid[])
{
int type;
ENTRY;
for (type = 0; type < MAXQUOTAS; type++) {
struct osc_quota_info *oqi;
oqi = cfs_hash_lookup(cli->cl_quota_hash[type], &qid[type]);
if (oqi) {
/* do not try to access oqi here, it could have been
* freed by osc_quota_setdq() */
/* the slot is busy, the user is about to run out of
* quota space on this OST */
CDEBUG(D_QUOTA, "chkdq found noquota for %s %d\n",
type == USRQUOTA ? "user" : "grout", qid[type]);
RETURN(NO_QUOTA);
}
}
RETURN(QUOTA_OK);
}
struct lustre_qunit_size *quota_search_lqs(unsigned long long lqs_key,
struct lustre_quota_ctxt *qctxt,
int create)
{
struct lustre_qunit_size *lqs;
struct lustre_qunit_size *lqs2;
cfs_hash_t *hs = NULL;
int rc = 0;
cfs_spin_lock(&qctxt->lqc_lock);
if (qctxt->lqc_valid) {
LASSERT(qctxt->lqc_lqs_hash != NULL);
hs = cfs_hash_getref(qctxt->lqc_lqs_hash);
}
cfs_spin_unlock(&qctxt->lqc_lock);
if (hs == NULL) {
rc = -EBUSY;
goto out;
}
/* cfs_hash_lookup will +1 refcount for caller */
lqs = cfs_hash_lookup(qctxt->lqc_lqs_hash, &lqs_key);
if (lqs != NULL) /* found */
goto out_put;
if (!create)
goto out_put;
OBD_ALLOC_PTR(lqs);
if (!lqs) {
rc = -ENOMEM;
goto out_put;
}
lqs->lqs_key = lqs_key;
cfs_spin_lock_init(&lqs->lqs_lock);
lqs->lqs_bwrite_pending = 0;
lqs->lqs_iwrite_pending = 0;
lqs->lqs_ino_rec = 0;
lqs->lqs_blk_rec = 0;
lqs->lqs_id = LQS_KEY_ID(lqs->lqs_key);
lqs->lqs_flags = LQS_KEY_GRP(lqs->lqs_key) ? LQUOTA_FLAGS_GRP : 0;
lqs->lqs_bunit_sz = qctxt->lqc_bunit_sz;
lqs->lqs_iunit_sz = qctxt->lqc_iunit_sz;
lqs->lqs_btune_sz = qctxt->lqc_btune_sz;
lqs->lqs_itune_sz = qctxt->lqc_itune_sz;
if (qctxt->lqc_handler) {
lqs->lqs_last_bshrink = 0;
lqs->lqs_last_ishrink = 0;
}
lqs->lqs_ctxt = qctxt; /* must be called before lqs_initref */
cfs_atomic_set(&lqs->lqs_refcount, 1); /* 1 for caller */
cfs_atomic_inc(&lqs->lqs_ctxt->lqc_lqs);
/* lqc_lqs_hash will take +1 refcount on lqs on adding */
lqs2 = cfs_hash_findadd_unique(qctxt->lqc_lqs_hash,
&lqs->lqs_key, &lqs->lqs_hash);
if (lqs2 == lqs) /* added to hash */
goto out_put;
create = 0;
lqs_putref(lqs);
lqs = lqs2;
out_put:
cfs_hash_putref(hs);
out:
if (rc != 0) { /* error */
CERROR("get lqs error(rc: %d)\n", rc);
return ERR_PTR(rc);
}
if (lqs != NULL) {
LQS_DEBUG(lqs, "%s\n",
(create == 1 ? "create lqs" : "search lqs"));
}
return lqs;
}