static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct obd_device *obd = container_of(kobj, struct obd_device,
obd_kobj);
struct obd_statfs osfs;
int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
return sprintf(buf, "%u\n", osfs.os_bsize);
return rc;
}
static int ll_blksize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, "%u\n", osfs.os_bsize);
return rc;
}
static ssize_t blocksize_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
ll_kobj);
struct obd_statfs osfs;
int rc;
rc = ll_statfs_internal(sbi->ll_sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
return sprintf(buf, "%u\n", osfs.os_bsize);
return rc;
}
static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct obd_device *obd = container_of(kobj, struct obd_device,
obd_kobj);
struct obd_statfs osfs;
int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
__u64 result = osfs.os_blocks;
while (blk_size >>= 1)
result <<= 1;
return sprintf(buf, "%llu\n", result);
}
static int ll_rd_blksize(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
struct super_block *sb = (struct super_block *)data;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
*eof = 1;
rc = snprintf(page, count, "%u\n", osfs.os_bsize);
}
return rc;
}
static int ll_kbytestotal_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = (struct super_block *)m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
__u64 result = osfs.os_blocks;
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, "%llu\n", result);
}
static ssize_t kbytestotal_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct ll_sb_info *sbi = container_of(kobj, struct ll_sb_info,
ll_kobj);
struct obd_statfs osfs;
int rc;
rc = ll_statfs_internal(sbi->ll_sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
__u64 result = osfs.os_blocks;
while (blk_size >>= 1)
result <<= 1;
rc = sprintf(buf, "%llu\n", result);
}
static int ll_rd_kbytestotal(char *page, char **start, off_t off, int count,
int *eof, void *data)
{
struct super_block *sb = (struct super_block *)data;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
__u64 result = osfs.os_blocks;
while (blk_size >>= 1)
result <<= 1;
*eof = 1;
rc = snprintf(page, count, LPU64"\n", result);
}
/**
* Try to consume local quota space.
*
* \param lqe - is the qid entry to be processed
* \param space - is the amount of quota space needed to complete the operation
*
* \retval 0 - success
* \retval -EDQUOT - out of quota
* \retval -EAGAIN - need to acquire space from master
*/
static int qsd_acquire_local(struct lquota_entry *lqe, __u64 space)
{
__u64 usage;
int rc;
ENTRY;
if (!lqe->lqe_enforced)
/* not enforced any more, we are good */
RETURN(-ESRCH);
lqe_write_lock(lqe);
/* use latest usage */
usage = lqe->lqe_usage;
/* take pending write into account */
usage += lqe->lqe_pending_write;
if (space + usage <= lqe->lqe_granted - lqe->lqe_pending_rel) {
/* Yay! we got enough space */
lqe->lqe_pending_write += space;
lqe->lqe_waiting_write -= space;
rc = 0;
/* lqe_edquot flag is used to avoid flooding dqacq requests when
* the user is over quota, however, the lqe_edquot could be stale
* sometimes due to the race reply of dqacq vs. id lock glimpse
* (see LU-4505), so we revalidate it every 5 seconds. */
} else if (lqe->lqe_edquot &&
cfs_time_before_64(cfs_time_shift_64(-5),
lqe->lqe_edquot_time)) {
rc = -EDQUOT;
}else {
rc = -EAGAIN;
}
lqe_write_unlock(lqe);
RETURN(rc);
}
/**
* Acquire quota space from master.
* There are at most 1 in-flight dqacq/dqrel.
*
* \param env - the environment passed by the caller
* \param lqe - is the qid entry to be processed
*
* \retval 0 - success
* \retval -EDQUOT - out of quota
* \retval -EINPROGRESS - inform client to retry write/create
* \retval -EBUSY - already a quota request in flight
* \retval -ve - other appropriate errors
*/
static int qsd_acquire_remote(const struct lu_env *env,
struct lquota_entry *lqe)
{
struct qsd_thread_info *qti = qsd_info(env);
struct quota_body *qbody = &qti->qti_body;
struct qsd_instance *qsd;
struct qsd_qtype_info *qqi;
int rc;
ENTRY;
memset(qbody, 0, sizeof(*qbody));
rc = qsd_ready(lqe, &qbody->qb_glb_lockh);
if (rc)
RETURN(rc);
qqi = lqe2qqi(lqe);
qsd = qqi->qqi_qsd;
lqe_write_lock(lqe);
/* is quota really enforced for this id? */
if (!lqe->lqe_enforced) {
lqe_write_unlock(lqe);
LQUOTA_DEBUG(lqe, "quota not enforced any more");
RETURN(0);
}
/* fill qb_count & qb_flags */
if (!qsd_calc_acquire(lqe, qbody)) {
lqe_write_unlock(lqe);
LQUOTA_DEBUG(lqe, "No acquire required");
RETURN(0);
}
/* check whether an acquire request completed recently */
if (lqe->lqe_acq_rc != 0 &&
cfs_time_before_64(cfs_time_shift_64(-1), lqe->lqe_acq_time)) {
lqe_write_unlock(lqe);
LQUOTA_DEBUG(lqe, "using cached return code %d", lqe->lqe_acq_rc);
RETURN(lqe->lqe_acq_rc);
}
/* only 1 quota request in flight for a given ID is allowed */
rc = qsd_request_enter(lqe);
if (rc) {
lqe_write_unlock(lqe);
RETURN(rc);
}
lustre_handle_copy(&qti->qti_lockh, &lqe->lqe_lockh);
lqe_write_unlock(lqe);
/* hold a refcount until completion */
lqe_getref(lqe);
/* fill other quota body fields */
qbody->qb_fid = qqi->qqi_fid;
qbody->qb_id = lqe->lqe_id;
/* check whether we already own a valid lock for this ID */
rc = qsd_id_lock_match(&qti->qti_lockh, &qbody->qb_lockh);
if (rc) {
struct lquota_lvb *lvb;
OBD_ALLOC_PTR(lvb);
if (lvb == NULL) {
rc = -ENOMEM;
qsd_req_completion(env, qqi, qbody, NULL,
&qti->qti_lockh, NULL, lqe, rc);
RETURN(rc);
}
/* no lock found, should use intent */
rc = qsd_intent_lock(env, qsd->qsd_exp, qbody, true,
IT_QUOTA_DQACQ, qsd_req_completion,
qqi, lvb, (void *)lqe);
} else {
/* lock found, should use regular dqacq */
rc = qsd_send_dqacq(env, qsd->qsd_exp, qbody, true,
qsd_req_completion, qqi, &qti->qti_lockh,
lqe);
}
/* the completion function will be called by qsd_send_dqacq or
* qsd_intent_lock */
RETURN(rc);
}
