static inline void enc_pools_wakeup(void)
{
LASSERT_SPIN_LOCKED(&page_pools.epp_lock);
LASSERT(page_pools.epp_waitqlen >= 0);
if (unlikely(page_pools.epp_waitqlen)) {
LASSERT(cfs_waitq_active(&page_pools.epp_waitq));
cfs_waitq_broadcast(&page_pools.epp_waitq);
}
}
/**
* This function is charge of recording lqs_ino_rec and
* lqs_blk_rec. when a lquota slave checks a quota
* request(check_cur_qunit) and finishes a quota
* request(dqacq_completion), it will be called.
* is_chk: whether it is checking quota; otherwise, it is finishing
* is_acq: whether it is acquiring; otherwise, it is releasing
*/
void quota_compute_lqs(struct qunit_data *qdata, struct lustre_qunit_size *lqs,
int is_chk, int is_acq)
{
long long *rec;
LASSERT(qdata && lqs);
LASSERT_SPIN_LOCKED(&lqs->lqs_lock);
rec = QDATA_IS_BLK(qdata) ? &lqs->lqs_blk_rec : &lqs->lqs_ino_rec;
if (!!is_chk + !!is_acq == 1)
*rec -= qdata->qd_count;
else
*rec += qdata->qd_count;
}
/*
* caller must hold spinlock
*/
static
void ctx_unhash_pf(struct ptlrpc_cli_ctx *ctx, cfs_hlist_head_t *freelist)
{
LASSERT_SPIN_LOCKED(&ctx->cc_sec->ps_lock);
LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0);
LASSERT(test_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags));
LASSERT(!cfs_hlist_unhashed(&ctx->cc_cache));
clear_bit(PTLRPC_CTX_CACHED_BIT, &ctx->cc_flags);
if (cfs_atomic_dec_and_test(&ctx->cc_refcount)) {
__cfs_hlist_del(&ctx->cc_cache);
cfs_hlist_add_head(&ctx->cc_cache, freelist);
} else {
cfs_hlist_del_init(&ctx->cc_cache);
}
}
/* Must be called under the lov_stripe_lock() */
int lov_adjust_kms(struct obd_export *exp, struct lov_stripe_md *lsm,
obd_off size, int shrink)
{
struct lov_oinfo *loi;
int stripe = 0;
__u64 kms;
ENTRY;
LASSERT_SPIN_LOCKED(&lsm->lsm_lock);
#ifdef __KERNEL__
LASSERT(lsm->lsm_lock_owner == cfs_curproc_pid());
#endif
if (shrink) {
for (; stripe < lsm->lsm_stripe_count; stripe++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[stripe];
kms = lov_size_to_stripe(lsm, size, stripe);
CDEBUG(D_INODE,
"stripe %d KMS %sing "LPU64"->"LPU64"\n",
stripe, kms > loi->loi_kms ? "increas":"shrink",
loi->loi_kms, kms);
loi_kms_set(loi, loi->loi_lvb.lvb_size = kms);
}
RETURN(0);
}
if (size > 0)
stripe = lov_stripe_number(lsm, size - 1);
kms = lov_size_to_stripe(lsm, size, stripe);
loi = lsm->lsm_oinfo[stripe];
CDEBUG(D_INODE, "stripe %d KMS %sincreasing "LPU64"->"LPU64"\n",
stripe, kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms);
if (kms > loi->loi_kms)
loi_kms_set(loi, kms);
RETURN(0);
}
/** Merge the lock value block(&lvb) attributes and KMS from each of the
* stripes in a file into a single lvb. It is expected that the caller
* initializes the current atime, mtime, ctime to avoid regressing a more
* uptodate time on the local client.
*/
int lov_merge_lvb_kms(struct lov_stripe_md *lsm,
struct ost_lvb *lvb, __u64 *kms_place)
{
__u64 size = 0;
__u64 kms = 0;
__u64 blocks = 0;
obd_time current_mtime = lvb->lvb_mtime;
obd_time current_atime = lvb->lvb_atime;
obd_time current_ctime = lvb->lvb_ctime;
int i;
int rc = 0;
LASSERT_SPIN_LOCKED(&lsm->lsm_lock);
#ifdef __KERNEL__
LASSERT(lsm->lsm_lock_owner == cfs_curproc_pid());
#endif
CDEBUG(D_INODE, "MDT FID "DFID" initial value: s="LPU64" m="LPU64
" a="LPU64" c="LPU64" b="LPU64"\n",
lsm->lsm_object_seq, (__u32)lsm->lsm_object_id,
(__u32)(lsm->lsm_object_id >> 32), lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
for (i = 0; i < lsm->lsm_stripe_count; i++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
obd_size lov_size, tmpsize;
if (OST_LVB_IS_ERR(loi->loi_lvb.lvb_blocks)) {
rc = OST_LVB_GET_ERR(loi->loi_lvb.lvb_blocks);
continue;
}
tmpsize = loi->loi_kms;
lov_size = lov_stripe_size(lsm, tmpsize, i);
if (lov_size > kms)
kms = lov_size;
if (loi->loi_lvb.lvb_size > tmpsize)
tmpsize = loi->loi_lvb.lvb_size;
lov_size = lov_stripe_size(lsm, tmpsize, i);
if (lov_size > size)
size = lov_size;
/* merge blocks, mtime, atime */
blocks += loi->loi_lvb.lvb_blocks;
if (loi->loi_lvb.lvb_mtime > current_mtime)
current_mtime = loi->loi_lvb.lvb_mtime;
if (loi->loi_lvb.lvb_atime > current_atime)
current_atime = loi->loi_lvb.lvb_atime;
if (loi->loi_lvb.lvb_ctime > current_ctime)
current_ctime = loi->loi_lvb.lvb_ctime;
CDEBUG(D_INODE, "MDT FID "DFID" on OST[%u]: s="LPU64" m="LPU64
" a="LPU64" c="LPU64" b="LPU64"\n",
lsm->lsm_object_seq, (__u32)lsm->lsm_object_id,
(__u32)(lsm->lsm_object_id >> 32), loi->loi_ost_idx,
loi->loi_lvb.lvb_size, loi->loi_lvb.lvb_mtime,
loi->loi_lvb.lvb_atime, loi->loi_lvb.lvb_ctime,
loi->loi_lvb.lvb_blocks);
}
*kms_place = kms;
lvb->lvb_size = size;
lvb->lvb_blocks = blocks;
lvb->lvb_mtime = current_mtime;
lvb->lvb_atime = current_atime;
lvb->lvb_ctime = current_ctime;
RETURN(rc);
}
