static void null_init_internal(void)
{
static CFS_HLIST_HEAD(__list);
null_sec.ps_policy = &null_policy;
cfs_atomic_set(&null_sec.ps_refcount, 1); /* always busy */
null_sec.ps_id = -1;
null_sec.ps_import = NULL;
null_sec.ps_flvr.sf_rpc = SPTLRPC_FLVR_NULL;
null_sec.ps_flvr.sf_flags = 0;
null_sec.ps_part = LUSTRE_SP_ANY;
null_sec.ps_dying = 0;
cfs_spin_lock_init(&null_sec.ps_lock);
cfs_atomic_set(&null_sec.ps_nctx, 1); /* for "null_cli_ctx" */
CFS_INIT_LIST_HEAD(&null_sec.ps_gc_list);
null_sec.ps_gc_interval = 0;
null_sec.ps_gc_next = 0;
cfs_hlist_add_head(&null_cli_ctx.cc_cache, &__list);
cfs_atomic_set(&null_cli_ctx.cc_refcount, 1); /* for hash */
null_cli_ctx.cc_sec = &null_sec;
null_cli_ctx.cc_ops = &null_ctx_ops;
null_cli_ctx.cc_expire = 0;
null_cli_ctx.cc_flags = PTLRPC_CTX_CACHED | PTLRPC_CTX_ETERNAL |
PTLRPC_CTX_UPTODATE;
null_cli_ctx.cc_vcred.vc_uid = 0;
cfs_spin_lock_init(&null_cli_ctx.cc_lock);
CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_req_list);
CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_gc_chain);
}
struct page *alloc_page(int flags)
{
struct page *pg;
pg = kmem_cache_alloc(cfs_page_t_slab, 0);
if (NULL == pg) {
cfs_enter_debugger();
return NULL;
}
memset(pg, 0, sizeof(struct page));
pg->addr = kmem_cache_alloc(cfs_page_p_slab, 0);
cfs_atomic_set(&pg->count, 1);
if (pg->addr) {
if (cfs_is_flag_set(flags, __GFP_ZERO))
memset(pg->addr, 0, PAGE_CACHE_SIZE);
cfs_atomic_inc(&libcfs_total_pages);
} else {
cfs_enter_debugger();
kmem_cache_free(cfs_page_t_slab, pg);
pg = NULL;
}
return pg;
}
/*****************************************************************************
*
* Lov object operations.
*
*/
int lov_object_init(const struct lu_env *env, struct lu_object *obj,
const struct lu_object_conf *conf)
{
struct lov_device *dev = lu2lov_dev(obj->lo_dev);
struct lov_object *lov = lu2lov(obj);
const struct cl_object_conf *cconf = lu2cl_conf(conf);
union lov_layout_state *set = &lov->u;
const struct lov_layout_operations *ops;
int result;
ENTRY;
init_rwsem(&lov->lo_type_guard);
cfs_atomic_set(&lov->lo_active_ios, 0);
init_waitqueue_head(&lov->lo_waitq);
cl_object_page_init(lu2cl(obj), sizeof(struct lov_page));
/* no locking is necessary, as object is being created */
lov->lo_type = lov_type(cconf->u.coc_md->lsm);
ops = &lov_dispatch[lov->lo_type];
result = ops->llo_init(env, dev, lov, cconf, set);
if (result == 0)
ops->llo_install(env, lov, set);
RETURN(result);
}
int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count,
int pattern, int magic)
{
int i, lsm_size;
ENTRY;
CDEBUG(D_INFO, "alloc lsm, stripe_count %d\n", stripe_count);
*lsmp = lsm_alloc_plain(stripe_count, &lsm_size);
if (!*lsmp) {
CERROR("can't allocate lsmp stripe_count %d\n", stripe_count);
RETURN(-ENOMEM);
}
cfs_atomic_set(&(*lsmp)->lsm_refc, 1);
spin_lock_init(&(*lsmp)->lsm_lock);
(*lsmp)->lsm_magic = magic;
(*lsmp)->lsm_stripe_count = stripe_count;
(*lsmp)->lsm_maxbytes = LUSTRE_STRIPE_MAXBYTES * stripe_count;
(*lsmp)->lsm_pattern = pattern;
(*lsmp)->lsm_pool_name[0] = '\0';
(*lsmp)->lsm_layout_gen = 0;
(*lsmp)->lsm_oinfo[0]->loi_ost_idx = ~0;
for (i = 0; i < stripe_count; i++)
loi_init((*lsmp)->lsm_oinfo[i]);
RETURN(lsm_size);
}
/*
* Allocate a new log or catalog handle
* Used inside llog_open().
*/
struct llog_handle *llog_alloc_handle(void)
{
struct llog_handle *loghandle;
OBD_ALLOC_PTR(loghandle);
if (loghandle == NULL)
return NULL;
init_rwsem(&loghandle->lgh_lock);
spin_lock_init(&loghandle->lgh_hdr_lock);
CFS_INIT_LIST_HEAD(&loghandle->u.phd.phd_entry);
cfs_atomic_set(&loghandle->lgh_refcount, 1);
return loghandle;
}
static int osc_wr_resend_count(struct file *file, const char *buffer,
unsigned long count, void *data)
{
struct obd_device *obd = data;
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
if (rc)
return rc;
if (val < 0)
return -EINVAL;
cfs_atomic_set(&obd->u.cli.cl_resends, val);
return count;
}
struct page *virt_to_page(void *addr)
{
struct page *pg;
pg = kmem_cache_alloc(cfs_page_t_slab, 0);
if (NULL == pg) {
cfs_enter_debugger();
return NULL;
}
memset(pg, 0, sizeof(struct page));
pg->addr = (void *)((__u64)addr & (~((__u64)PAGE_SIZE-1)));
pg->mapping = addr;
cfs_atomic_set(&pg->count, 1);
set_bit(PG_virt, &(pg->flags));
cfs_enter_debugger();
return pg;
}
struct ptlrpc_connection *
ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self,
struct obd_uuid *uuid)
{
struct ptlrpc_connection *conn, *conn2;
ENTRY;
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;
CFS_INIT_HLIST_NODE(&conn->c_hash);
cfs_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.
*/
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, cfs_atomic_read(&conn->c_refcount),
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
int __obd_fail_check_set(__u32 id, __u32 value, int set)
{
static cfs_atomic_t obd_fail_count = CFS_ATOMIC_INIT(0);
LASSERT(!(id & OBD_FAIL_ONCE));
if ((obd_fail_loc & (OBD_FAILED | OBD_FAIL_ONCE)) ==
(OBD_FAILED | OBD_FAIL_ONCE)) {
cfs_atomic_set(&obd_fail_count, 0); /* paranoia */
return 0;
}
/* Fail 1/obd_fail_val times */
if (obd_fail_loc & OBD_FAIL_RAND) {
if (obd_fail_val < 2 || cfs_rand() % obd_fail_val > 0)
return 0;
}
/* Skip the first obd_fail_val, then fail */
if (obd_fail_loc & OBD_FAIL_SKIP) {
if (cfs_atomic_inc_return(&obd_fail_count) <= obd_fail_val)
return 0;
}
/* Fail obd_fail_val times, overridden by FAIL_ONCE */
if (obd_fail_loc & OBD_FAIL_SOME &&
(!(obd_fail_loc & OBD_FAIL_ONCE) || obd_fail_val <= 1)) {
int count = cfs_atomic_inc_return(&obd_fail_count);
if (count >= obd_fail_val) {
cfs_set_bit(OBD_FAIL_ONCE_BIT, &obd_fail_loc);
cfs_atomic_set(&obd_fail_count, 0);
/* we are lost race to increase obd_fail_count */
if (count > obd_fail_val)
return 0;
}
}
if ((set == OBD_FAIL_LOC_ORSET || set == OBD_FAIL_LOC_RESET) &&
(value & OBD_FAIL_ONCE))
cfs_set_bit(OBD_FAIL_ONCE_BIT, &obd_fail_loc);
/* Lost race to set OBD_FAILED_BIT. */
if (cfs_test_and_set_bit(OBD_FAILED_BIT, &obd_fail_loc)) {
/* If OBD_FAIL_ONCE is valid, only one process can fail,
* otherwise multi-process can fail at the same time. */
if (obd_fail_loc & OBD_FAIL_ONCE)
return 0;
}
switch (set) {
case OBD_FAIL_LOC_NOSET:
break;
case OBD_FAIL_LOC_ORSET:
obd_fail_loc |= value & ~(OBD_FAILED | OBD_FAIL_ONCE);
break;
case OBD_FAIL_LOC_RESET:
obd_fail_loc = value;
break;
default:
LASSERTF(0, "called with bad set %u\n", set);
break;
}
return 1;
}
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;
}
int __cfs_fail_check_set(__u32 id, __u32 value, int set)
{
static cfs_atomic_t cfs_fail_count = CFS_ATOMIC_INIT(0);
LASSERT(!(id & CFS_FAIL_ONCE));
if ((cfs_fail_loc & (CFS_FAILED | CFS_FAIL_ONCE)) ==
(CFS_FAILED | CFS_FAIL_ONCE)) {
cfs_atomic_set(&cfs_fail_count, 0); /* paranoia */
return 0;
}
/* Fail 1/cfs_fail_val times */
if (cfs_fail_loc & CFS_FAIL_RAND) {
if (cfs_fail_val < 2 || cfs_rand() % cfs_fail_val > 0)
return 0;
}
/* Skip the first cfs_fail_val, then fail */
if (cfs_fail_loc & CFS_FAIL_SKIP) {
if (cfs_atomic_inc_return(&cfs_fail_count) <= cfs_fail_val)
return 0;
}
/* check cfs_fail_val... */
if (set == CFS_FAIL_LOC_VALUE) {
if (cfs_fail_val != -1 && cfs_fail_val != value)
return 0;
}
/* Fail cfs_fail_val times, overridden by FAIL_ONCE */
if (cfs_fail_loc & CFS_FAIL_SOME &&
(!(cfs_fail_loc & CFS_FAIL_ONCE) || cfs_fail_val <= 1)) {
int count = cfs_atomic_inc_return(&cfs_fail_count);
if (count >= cfs_fail_val) {
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
cfs_atomic_set(&cfs_fail_count, 0);
/* we are lost race to increase */
if (count > cfs_fail_val)
return 0;
}
}
if ((set == CFS_FAIL_LOC_ORSET || set == CFS_FAIL_LOC_RESET) &&
(value & CFS_FAIL_ONCE))
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
/* Lost race to set CFS_FAILED_BIT. */
if (test_and_set_bit(CFS_FAILED_BIT, &cfs_fail_loc)) {
/* If CFS_FAIL_ONCE is valid, only one process can fail,
* otherwise multi-process can fail at the same time. */
if (cfs_fail_loc & CFS_FAIL_ONCE)
return 0;
}
switch (set) {
case CFS_FAIL_LOC_NOSET:
case CFS_FAIL_LOC_VALUE:
break;
case CFS_FAIL_LOC_ORSET:
cfs_fail_loc |= value & ~(CFS_FAILED | CFS_FAIL_ONCE);
break;
case CFS_FAIL_LOC_RESET:
cfs_fail_loc = value;
break;
default:
LASSERTF(0, "called with bad set %u\n", set);
break;
}
return 1;
}
/*
* Allocate and initialize a qsd_qtype_info structure for quota type \qtype.
* This opens the accounting object and initializes the proc file.
* It's called on OSD start when the qsd_prepare() is invoked on the qsd
* instance.
*
* \param env - the environment passed by the caller
* \param qsd - is the qsd instance which will be in charge of the new
* qsd_qtype_info instance.
* \param qtype - is quota type to set up
*
* \retval - 0 on success and qsd->qsd_type_array[qtype] is allocated,
* appropriate error on failure
*/
static int qsd_qtype_init(const struct lu_env *env, struct qsd_instance *qsd,
int qtype)
{
struct qsd_qtype_info *qqi;
int rc;
struct obd_uuid uuid;
ENTRY;
LASSERT(qsd->qsd_type_array[qtype] == NULL);
/* allocate structure for this quota type */
OBD_ALLOC_PTR(qqi);
if (qqi == NULL)
RETURN(-ENOMEM);
qsd->qsd_type_array[qtype] = qqi;
cfs_atomic_set(&qqi->qqi_ref, 1); /* referenced from qsd */
/* set backpointer and other parameters */
qqi->qqi_qsd = qsd;
qqi->qqi_qtype = qtype;
lu_ref_init(&qqi->qqi_reference);
lquota_generate_fid(&qqi->qqi_fid, qsd->qsd_pool_id, QSD_RES_TYPE(qsd),
qtype);
qqi->qqi_glb_uptodate = false;
qqi->qqi_slv_uptodate = false;
qqi->qqi_reint = false;
init_waitqueue_head(&qqi->qqi_reint_thread.t_ctl_waitq);
thread_set_flags(&qqi->qqi_reint_thread, SVC_STOPPED);
CFS_INIT_LIST_HEAD(&qqi->qqi_deferred_glb);
CFS_INIT_LIST_HEAD(&qqi->qqi_deferred_slv);
/* open accounting object */
LASSERT(qqi->qqi_acct_obj == NULL);
qqi->qqi_acct_obj = acct_obj_lookup(env, qsd->qsd_dev, qtype);
if (IS_ERR(qqi->qqi_acct_obj)) {
CDEBUG(D_QUOTA, "%s: no %s space accounting support rc:%ld\n",
qsd->qsd_svname, QTYPE_NAME(qtype),
PTR_ERR(qqi->qqi_acct_obj));
qqi->qqi_acct_obj = NULL;
qsd->qsd_acct_failed = true;
}
/* open global index copy */
LASSERT(qqi->qqi_glb_obj == NULL);
qqi->qqi_glb_obj = lquota_disk_glb_find_create(env, qsd->qsd_dev,
qsd->qsd_root,
&qqi->qqi_fid, true);
if (IS_ERR(qqi->qqi_glb_obj)) {
CERROR("%s: can't open global index copy "DFID" %ld\n",
qsd->qsd_svname, PFID(&qqi->qqi_fid),
PTR_ERR(qqi->qqi_glb_obj));
GOTO(out, rc = PTR_ERR(qqi->qqi_glb_obj));
}
qqi->qqi_glb_ver = dt_version_get(env, qqi->qqi_glb_obj);
/* open slave index copy */
LASSERT(qqi->qqi_slv_obj == NULL);
obd_str2uuid(&uuid, qsd->qsd_svname);
qqi->qqi_slv_obj = lquota_disk_slv_find_create(env, qsd->qsd_dev,
qsd->qsd_root,
&qqi->qqi_fid, &uuid,
true);
if (IS_ERR(qqi->qqi_slv_obj)) {
CERROR("%s: can't open slave index copy "DFID" %ld\n",
qsd->qsd_svname, PFID(&qqi->qqi_fid),
PTR_ERR(qqi->qqi_slv_obj));
GOTO(out, rc = PTR_ERR(qqi->qqi_slv_obj));
}
qqi->qqi_slv_ver = dt_version_get(env, qqi->qqi_slv_obj);
/* allocate site */
qqi->qqi_site = lquota_site_alloc(env, qqi, false, qtype, &qsd_lqe_ops);
if (IS_ERR(qqi->qqi_site)) {
CERROR("%s: can't allocate site "DFID" %ld\n", qsd->qsd_svname,
PFID(&qqi->qqi_fid), PTR_ERR(qqi->qqi_site));
GOTO(out, rc = PTR_ERR(qqi->qqi_site));
}
/* register proc entry for accounting & global index copy objects */
rc = lprocfs_seq_create(qsd->qsd_proc,
qtype == USRQUOTA ? "acct_user" : "acct_group",
0444, &lprocfs_quota_seq_fops,
qqi->qqi_acct_obj);
if (rc) {
CERROR("%s: can't add procfs entry for accounting file %d\n",
qsd->qsd_svname, rc);
GOTO(out, rc);
}
rc = lprocfs_seq_create(qsd->qsd_proc,
qtype == USRQUOTA ? "limit_user" : "limit_group",
0444, &lprocfs_quota_seq_fops,
qqi->qqi_glb_obj);
if (rc) {
CERROR("%s: can't add procfs entry for global index copy %d\n",
qsd->qsd_svname, rc);
GOTO(out, rc);
}
EXIT;
out:
if (rc)
qsd_qtype_fini(env, qsd, qtype);
return rc;
}
