LASSERT(!interval_is_intree(&node->li_node));
idx = ldlm_mode_to_index(lock->l_granted_mode);
- LASSERT(lock->l_granted_mode == 1 << idx);
+ LASSERT(lock->l_granted_mode == BIT(idx));
LASSERT(lock->l_granted_mode == res->lr_itree[idx].lit_mode);
/* node extent initialize */
return;
idx = ldlm_mode_to_index(lock->l_granted_mode);
- LASSERT(lock->l_granted_mode == 1 << idx);
+ LASSERT(lock->l_granted_mode == BIT(idx));
tree = &res->lr_itree[idx];
LASSERT(tree->lit_root != NULL); /* assure the tree is not null */
if (list_empty(head))
continue;
- if (hint && !(hint->l_policy_data.l_inodebits.bits & (1 << i)))
+ if (hint && !(hint->l_policy_data.l_inodebits.bits & BIT(i)))
continue;
node = list_entry(head->next, struct ldlm_ibits_node,
if (head == &res->lr_waiting) {
for (i = 0; i < MDS_INODELOCK_NUMBITS; i++) {
- if (lock->l_policy_data.l_inodebits.bits & (1 << i))
+ if (lock->l_policy_data.l_inodebits.bits & BIT(i))
list_add_tail(&lock->l_ibits_node->lin_link[i],
&res->lr_ibits_queues->liq_waiting[i]);
}
/* Initialize interval trees for each lock mode. */
for (idx = 0; idx < LCK_MODE_NUM; idx++) {
res->lr_itree[idx].lit_size = 0;
- res->lr_itree[idx].lit_mode = 1 << idx;
+ res->lr_itree[idx].lit_mode = BIT(idx);
res->lr_itree[idx].lit_root = NULL;
}
return true;
seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
- for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
+ for (i = 0, flag = 1; bits != 0; i++, flag = BIT(i)) {
if (flag & bits) {
bits &= ~flag;
if (names[i] != NULL) {
GOTO(out, rc = -ENOTSUPP);
}
- for (i = 0, type = 1 << i; i < LFSCK_TYPE_BITS;
- i++, type = 1 << i) {
+ for (i = 0, type = BIT(i); i < LFSCK_TYPE_BITS;
+ i++, type = BIT(i)) {
if (!(que->lu_types & type))
continue;
if (!(que->lu_flags & LPF_WAIT))
GOTO(out, rc);
- for (i = 0, type = 1 << i; i < LFSCK_TYPE_BITS;
- i++, type = 1 << i) {
+ for (i = 0, type = BIT(i); i < LFSCK_TYPE_BITS;
+ i++, type = BIT(i)) {
if (!(que->lu_types & type))
continue;
count = 0;
for (i = 0; i < sizeof(archive_mask) * 8; i++) {
- if ((1 << i) & archive_mask) {
+ if (BIT(i) & archive_mask) {
lk->lk_data[count] = i + 1;
count++;
}
flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
for (i = 0; i < MDS_INODELOCK_NUMBITS && *bits != 0; i++) {
- policy.l_inodebits.bits = *bits & (1 << i);
+ policy.l_inodebits.bits = *bits & BIT(i);
if (policy.l_inodebits.bits == 0)
continue;
- if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
- &policy, mode, &lockh)) {
- struct ldlm_lock *lock;
-
- lock = ldlm_handle2lock(&lockh);
- if (lock) {
- *bits &=
- ~(lock->l_policy_data.l_inodebits.bits);
- LDLM_LOCK_PUT(lock);
- } else {
- *bits &= ~policy.l_inodebits.bits;
- }
- }
- }
+ if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
+ &policy, mode, &lockh)) {
+ struct ldlm_lock *lock;
+
+ lock = ldlm_handle2lock(&lockh);
+ if (lock) {
+ *bits &=
+ ~(lock->l_policy_data.l_inodebits.bits);
+ LDLM_LOCK_PUT(lock);
+ } else {
+ *bits &= ~policy.l_inodebits.bits;
+ }
+ }
+ }
RETURN(*bits == 0);
}
cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
- if ((1 << cap) & CFS_CAP_FS_MASK)
+ if (BIT(cap) & CFS_CAP_FS_MASK)
cap_lower(cred->cap_effective, cap);
}
old_cred = override_creds(cred);
struct lovsub_object;
enum lov_device_flags {
- LOV_DEV_INITIALIZED = 1 << 0
+ LOV_DEV_INITIALIZED = BIT(0),
};
/*
ENTRY;
- if (mdd->mdd_cl.mc_mask & (1 << CL_MARK)) {
+ if (mdd->mdd_cl.mc_mask & BIT(CL_MARK)) {
mdd->mdd_cl.mc_starttime = ktime_get();
RETURN(0);
}
enum mod_flags {
/* The dir object has been unlinked */
- DEAD_OBJ = 1 << 0,
- ORPHAN_OBJ = 1 << 1,
- VOLATILE_OBJ = 1 << 4,
+ DEAD_OBJ = BIT(0),
+ ORPHAN_OBJ = BIT(1),
+ VOLATILE_OBJ = BIT(4),
};
struct mdd_object {
const struct lu_ucred *uc;
if ((mdd->mdd_cl.mc_flags & CLM_ON) &&
- (mdd->mdd_cl.mc_mask & (1 << type))) {
+ (mdd->mdd_cl.mc_mask & BIT(type))) {
uc = lu_ucred_check(env);
return uc != NULL ? uc->uc_enable_audit : true;
int i = 0;
while (i < CL_LAST) {
- if (mdd->mdd_cl.mc_mask & (1 << i))
+ if (mdd->mdd_cl.mc_mask & BIT(i))
seq_printf(m, "%s ", changelog_type2str(i));
i++;
}
struct mdd_device *mdd = mdo2mdd(obj);
int bits, type = 0;
- bits = (valid & LA_SIZE) ? 1 << CL_TRUNC : 0;
- bits |= (valid & ~(LA_CTIME|LA_MTIME|LA_ATIME)) ? 1 << CL_SETATTR : 0;
- bits |= (valid & LA_MTIME) ? 1 << CL_MTIME : 0;
- bits |= (valid & LA_CTIME) ? 1 << CL_CTIME : 0;
- bits |= (valid & LA_ATIME) ? 1 << CL_ATIME : 0;
+ bits = (valid & LA_SIZE) ? BIT(CL_TRUNC) : 0;
+ bits |= (valid & ~(LA_CTIME|LA_MTIME|LA_ATIME)) ? BIT(CL_SETATTR) : 0;
+ bits |= (valid & LA_MTIME) ? BIT(CL_MTIME) : 0;
+ bits |= (valid & LA_CTIME) ? BIT(CL_CTIME) : 0;
+ bits |= (valid & LA_ATIME) ? BIT(CL_ATIME) : 0;
bits = bits & mdd->mdd_cl.mc_mask;
/* This is an implementation limit rather than a protocol limit */
BUILD_BUG_ON(CL_LAST > sizeof(int) * 8);
rc = mdd_open_sanity_check(env, mdd_obj, attr, open_flags,
spec->no_create);
- if ((rc == -EACCES) && (mdd->mdd_cl.mc_mask & (1 << CL_DN_OPEN)))
+ if ((rc == -EACCES) && (mdd->mdd_cl.mc_mask & BIT(CL_DN_OPEN)))
type = CL_DN_OPEN;
else if (rc != 0)
GOTO(out, rc);
* this is not a big deal if we have a CL_CLOSE entry with no matching
* CL_OPEN. Plus Changelogs mask may not change often.
*/
- if (((!(mdd->mdd_cl.mc_mask & (1 << CL_OPEN)) &&
+ if (((!(mdd->mdd_cl.mc_mask & BIT(CL_OPEN)) &&
(open_flags & (MDS_FMODE_WRITE | MDS_OPEN_APPEND |
MDS_OPEN_TRUNC))) ||
- ((mdd->mdd_cl.mc_mask & (1 << CL_OPEN)) && last_close_by_uid)) &&
+ ((mdd->mdd_cl.mc_mask & BIT(CL_OPEN)) && last_close_by_uid)) &&
!(ma->ma_valid & MA_FLAGS && ma->ma_attr_flags & MDS_RECOV_OPEN)) {
if (handle == NULL) {
handle = mdd_trans_create(env, mdo2mdd(obj));
nr_archives = 0;
for (i = 0; i < sizeof(archive_mask) * 8; i++) {
- if ((1 << i) & archive_mask) {
+ if (BIT(i) & archive_mask) {
archive_id[nr_archives] = i + 1;
nr_archives++;
}
list_for_each_entry(ha, &cdt->cdt_agents, ha_list) {
for (i = 0; (i < ha->ha_archive_cnt); i++) {
/* only send once for each archive_id */
- if ((1 << ha->ha_archive_id[i]) & archive_mask)
+ if (BIT(ha->ha_archive_id[i]) & archive_mask)
continue;
- archive_mask |= (1 << ha->ha_archive_id[i]);
+ archive_mask |= BIT(ha->ha_archive_id[i]);
/* XXX: it could make sense to gather all
* actions for the same archive_id like in
};
enum mdt_reint_flag {
- MRF_OPEN_TRUNC = 1 << 0,
+ MRF_OPEN_TRUNC = BIT(0),
};
/*
uc = lu_ucred(env);
uc_cap_save = uc->uc_cap;
- uc->uc_cap |= 1 << CFS_CAP_DAC_OVERRIDE;
+ uc->uc_cap |= BIT(CFS_CAP_DAC_OVERRIDE);
rc = mdo_create(env, mdt_object_child(local_root), &lname,
mdt_object_child(obj), spec, attr);
uc->uc_cap = uc_cap_save;
seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
- for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
+ for (i = 0, flag = 1; bits != 0; i++, flag = BIT(i)) {
if (flag & bits) {
bits &= ~flag;
seq_printf(m, "%s%c", names[i],
return 0;
for (i = 0; i < ARRAY_SIZE(cksum_name); i++) {
- if (((1 << i) & obd->u.cli.cl_supp_cksum_types) == 0)
+ if ((BIT(i) & obd->u.cli.cl_supp_cksum_types) == 0)
continue;
- if (obd->u.cli.cl_cksum_type == (1 << i))
+ if (obd->u.cli.cl_cksum_type == BIT(i))
seq_printf(m, "[%s] ", cksum_name[i]);
else
seq_printf(m, "%s ", cksum_name[i]);
/*
* this iterator will move (iam_it_next() will be called on it)
*/
- IAM_IT_MOVE = (1 << 0),
+ IAM_IT_MOVE = BIT(0),
/*
* tree can be updated through this iterator.
*/
- IAM_IT_WRITE = (1 << 1)
+ IAM_IT_WRITE = BIT(1)
};
/*
/*
* Supplementary info bits:
*/
-#define GSS_S_CONTINUE_NEEDED (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 0))
-#define GSS_S_DUPLICATE_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 1))
-#define GSS_S_OLD_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 2))
-#define GSS_S_UNSEQ_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 3))
-#define GSS_S_GAP_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 4))
+#define GSS_S_CONTINUE_NEEDED BIT(GSS_C_SUPPLEMENTARY_OFFSET + 0)
+#define GSS_S_DUPLICATE_TOKEN BIT(GSS_C_SUPPLEMENTARY_OFFSET + 1)
+#define GSS_S_OLD_TOKEN BIT(GSS_C_SUPPLEMENTARY_OFFSET + 2)
+#define GSS_S_UNSEQ_TOKEN BIT(GSS_C_SUPPLEMENTARY_OFFSET + 3)
+#define GSS_S_GAP_TOKEN BIT(GSS_C_SUPPLEMENTARY_OFFSET + 4)
/* XXXX these are not part of the GSSAPI C bindings! (but should be) */
};
enum rmf_flags {
- /**
- * The field is a string, must be NUL-terminated.
- */
- RMF_F_STRING = 1 << 0,
- /**
- * The field's buffer size need not match the declared \a rmf_size.
- */
- RMF_F_NO_SIZE_CHECK = 1 << 1,
- /**
- * The field's buffer size must be a whole multiple of the declared \a
- * rmf_size and the \a rmf_swabber function must work on the declared \a
- * rmf_size worth of bytes.
- */
- RMF_F_STRUCT_ARRAY = 1 << 2
+ /**
+ * The field is a string, must be NUL-terminated.
+ */
+ RMF_F_STRING = BIT(0),
+ /**
+ * The field's buffer size need not match the declared \a rmf_size.
+ */
+ RMF_F_NO_SIZE_CHECK = BIT(1),
+ /**
+ * The field's buffer size must be a whole multiple of the declared \a
+ * rmf_size and the \a rmf_swabber function must work on the declared \a
+ * rmf_size worth of bytes.
+ */
+ RMF_F_STRUCT_ARRAY = BIT(2),
};
struct req_capsule;
}
if (strchr(valstr, 'u'))
- enabled |= 1 << USRQUOTA;
+ enabled |= BIT(USRQUOTA);
if (strchr(valstr, 'g'))
- enabled |= 1 << GRPQUOTA;
+ enabled |= BIT(GRPQUOTA);
if (strchr(valstr, 'p'))
- enabled |= 1 << PRJQUOTA;
+ enabled |= BIT(PRJQUOTA);
mutex_lock(&qfs->qfs_mutex);
if (qfs->qfs_enabled[pool - LQUOTA_FIRST_RES] == enabled)
qqi = qsd->qsd_type_array[type];
/* only trigger reintegration if this
* type of quota is not enabled before */
- if ((old_enabled & 1 << type) ||
- !(enabled & 1 << type))
+ if ((old_enabled & BIT(type)) ||
+ !(enabled & BIT(type)))
continue;
if (qqi->qqi_acct_failed) {
pool = qsd->qsd_is_md ? LQUOTA_RES_MD : LQUOTA_RES_DT;
enabled = qsd->qsd_fsinfo->qfs_enabled[pool - LQUOTA_FIRST_RES];
- return enabled & (1 << type);
+ return enabled & BIT(type);
}
/* helper function to set new qunit and compute associated qtune value */