ldlm_created_callback ei_cb_created; /** lock created callback */
void *ei_cbdata; /** Data to be passed into callbacks. */
void *ei_namespace; /** lock namespace **/
- u64 ei_inodebits; /** lock inode bits **/
+ enum mds_ibits_locks ei_inodebits; /** lock inode bits **/
unsigned int ei_enq_slave:1; /** whether enqueue slave stripes */
unsigned int ei_req_slot:1; /** whether acquire rpc slot */
unsigned int ei_mod_slot:1; /** whether acquire mod rpc slot */
/** Non-rate-limited lock printing function for debugging purposes. */
#define LDLM_DEBUG(lock, fmt, a...) do { \
if (likely(lock != NULL)) { \
- LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_DLMTRACE, NULL); \
+ LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_DLMTRACE, NULL); \
ldlm_lock_debug(&msgdata, D_DLMTRACE, NULL, lock, \
"### " fmt, ##a); \
} else { \
struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- __u64 hint);
+ enum mds_ibits_locks hint);
/**
* Return values for lock iterators.
struct ldlm_lock *search_itree(struct ldlm_resource *res,
struct ldlm_match_data *data);
enum ldlm_mode ldlm_revalidate_lock_handle(const struct lustre_handle *lockh,
- __u64 *bits);
+ enum mds_ibits_locks *bits);
void ldlm_lock_mode_downgrade(struct ldlm_lock *lock, enum ldlm_mode new_mode);
void ldlm_lock_cancel(struct ldlm_lock *lock);
-void ldlm_reprocess_all(struct ldlm_resource *res, __u64 hint);
+void ldlm_reprocess_all(struct ldlm_resource *res, enum mds_ibits_locks hint);
void ldlm_reprocess_recovery_done(struct ldlm_namespace *ns);
void ldlm_lock_dump_handle(int level, const struct lustre_handle *lockh);
void ldlm_unlink_lock_skiplist(struct ldlm_lock *req);
struct ptlrpc_request *req,
enum ldlm_cancel_flags flags);
-int ldlm_inodebits_drop(struct ldlm_lock *lock, __u64 to_drop);
+int ldlm_inodebits_drop(struct ldlm_lock *lock, enum mds_ibits_locks to_drop);
int ldlm_cli_inodebits_convert(struct ldlm_lock *lock,
enum ldlm_cancel_flags cancel_flags);
return ex1->start <= ex2->start && ex1->end >= ex2->end;
}
-int ldlm_inodebits_drop(struct ldlm_lock *lock, __u64 to_drop);
-
#endif
/** @} LDLM */
int it_disposition;
int it_status;
__u64 it_lock_handle;
- __u64 it_lock_bits;
+ enum mds_ibits_locks it_lock_bits;
int it_lock_mode;
int it_remote_lock_mode;
__u64 it_remote_lock_handle;
int (*m_revalidate_lock)(struct obd_export *exp,
struct lookup_intent *it, struct lu_fid *fid,
- __u64 *bits);
+ enum mds_ibits_locks *bits);
int (*m_file_resync)(struct obd_export *exp,
struct md_op_data *op_data);
int (*m_set_lock_data)(struct obd_export *exp,
const struct lustre_handle *lockh, void *data,
- __u64 *bits);
+ enum mds_ibits_locks *bits);
enum ldlm_mode (*m_lock_match)(struct obd_export *exp, __u64 flags,
const struct lu_fid *fid,
static inline int md_set_lock_data(struct obd_export *exp,
const struct lustre_handle *lockh,
- void *data, __u64 *bits)
+ void *data, enum mds_ibits_locks *bits)
{
int rc;
static inline int md_revalidate_lock(struct obd_export *exp,
struct lookup_intent *it,
- struct lu_fid *fid, __u64 *bits)
+ struct lu_fid *fid,
+ enum mds_ibits_locks *bits)
{
int rc;
OBD_CONNECT_ATTRFID | \
OBD_CONNECT_FULL20)
+/* INODE LOCK PARTS */
+enum mds_ibits_locks {
+ MDS_INODELOCK_NONE = 0x000000000, /* no lock bits are used */
+ MDS_INODELOCK_LOOKUP = 0x000000001, /* For namespace, dentry etc Was
+ * used to protect permission
+ * (mode, owner, group, etc)
+ * before 2.4.
+ */
+ MDS_INODELOCK_UPDATE = 0x000000002, /* size, links, timestamps */
+ MDS_INODELOCK_OPEN = 0x000000004, /* For opened files */
+ MDS_INODELOCK_LAYOUT = 0x000000008, /* for layout */
+
+ /* The PERM bit is added in 2.4, and is used to protect permission
+ * (mode, owner, group, ACL, etc.) separate from LOOKUP lock.
+ * For remote directories (in DNE) these locks will be granted by
+ * different MDTs (different LDLM namespace).
+ *
+ * For local directory, the MDT always grants UPDATE|PERM together.
+ * For remote directory, master MDT (where remote directory is) grants
+ * UPDATE|PERM, and remote MDT (where name entry is) grants LOOKUP_LOCK.
+ */
+ MDS_INODELOCK_PERM = 0x000000010,
+ MDS_INODELOCK_XATTR = 0x000000020, /* non-permission extended attrs */
+ MDS_INODELOCK_DOM = 0x000000040, /* Data for Data-on-MDT files */
+ /* Do not forget to increase MDS_INODELOCK_NUMBITS when adding bits */
+
+ /* Reserve to make 64bit, not used anywhere, therefore
+ * MDS_INODELOCK_NUMBITS is not increased for this member
+ */
+ MDS_INODELOCK_64BIT = 0x100000000,
+};
+#define MDS_INODELOCK_NUMBITS 7
+/* This FULL lock is useful to take on unlink sort of operations */
+#define MDS_INODELOCK_FULL ((1 << MDS_INODELOCK_NUMBITS) - 1)
+/* DOM lock shouldn't be canceled early, use this macro for ELC */
+#define MDS_INODELOCK_ELC (MDS_INODELOCK_FULL & ~MDS_INODELOCK_DOM)
+
/* This structure is used for both request and reply.
*
* If we eventually have separate connect data for different types, which we
__u32 ocd_grant; /* initial cache grant amount (bytes) */
__u32 ocd_index; /* LOV index to connect to */
__u32 ocd_brw_size; /* Maximum BRW size in bytes */
- __u64 ocd_ibits_known; /* inode bits this client understands */
+ enum mds_ibits_locks ocd_ibits_known; /* inode bits this client understands */
__u8 ocd_grant_blkbits; /* log2 of the backend filesystem blocksize */
__u8 ocd_grant_inobits; /* log2 of the per-inode space consumption */
__u16 ocd_grant_tax_kb; /* extent insertion overhead, in 1K blocks */
#define DISP_OPEN_STRIPE 0x08000000
#define DISP_OPEN_DENY 0x10000000
-/* INODE LOCK PARTS */
-enum mds_ibits_locks {
- MDS_INODELOCK_LOOKUP = 0x000001, /* For namespace, dentry etc. Was
- * used to protect permission (mode,
- * owner, group, etc) before 2.4.
- */
- MDS_INODELOCK_UPDATE = 0x000002, /* size, links, timestamps */
- MDS_INODELOCK_OPEN = 0x000004, /* For opened files */
- MDS_INODELOCK_LAYOUT = 0x000008, /* for layout */
-
- /* The PERM bit is added in 2.4, and is used to protect permission
- * (mode, owner, group, ACL, etc.) separate from LOOKUP lock.
- * For remote directories (in DNE) these locks will be granted by
- * different MDTs (different LDLM namespace).
- *
- * For local directory, the MDT always grants UPDATE|PERM together.
- * For remote directory, master MDT (where remote directory is) grants
- * UPDATE|PERM, and remote MDT (where name entry is) grants LOOKUP_LOCK.
- */
- MDS_INODELOCK_PERM = 0x000010,
- MDS_INODELOCK_XATTR = 0x000020, /* non-permission extended attrs */
- MDS_INODELOCK_DOM = 0x000040, /* Data for Data-on-MDT files */
- /* Do not forget to increase MDS_INODELOCK_NUMBITS when adding bits */
-};
-#define MDS_INODELOCK_NUMBITS 7
-/* This FULL lock is useful to take on unlink sort of operations */
-#define MDS_INODELOCK_FULL ((1 << MDS_INODELOCK_NUMBITS) - 1)
-/* DOM lock shouldn't be canceled early, use this macro for ELC */
-#define MDS_INODELOCK_ELC (MDS_INODELOCK_FULL & ~MDS_INODELOCK_DOM)
-
/* NOTE: until Lustre 1.8.7/2.1.1 the fid_ver() was packed into name[2],
* but was moved into name[1] along with the OID to avoid consuming the
* name[2,3] fields that need to be used for the quota id (also a FID).
}
struct ldlm_inodebits {
- __u64 bits;
+ enum mds_ibits_locks bits;
union {
- __u64 try_bits; /* optional bits to try */
- __u64 cancel_bits; /* for lock convert */
+ enum mds_ibits_locks try_bits; /* optional bits to try */
+ enum mds_ibits_locks cancel_bits; /* for lock convert */
};
__u64 li_gid;
__u32 li_padding;
struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- __u64 mask)
+ enum mds_ibits_locks mask)
{
__u64 flags;
int rc = LDLM_ITER_CONTINUE;
CDEBUG(D_DLMTRACE, "--- Reprocess resource "DLDLMRES" (%p)\n",
PLDLMRES(res), res);
if (mask)
- CDEBUG(D_DLMTRACE, "Hint %llx\n", mask);
+ CDEBUG(D_DLMTRACE, "Hint %lx\n", mask);
else
mask = MDS_INODELOCK_FULL;
lock_res(res);
if (rc == -ERESTART) {
- mask = 0;
+ mask = MDS_INODELOCK_NONE;
GOTO(restart, rc);
}
}
enum ldlm_mode req_mode = req->l_req_mode;
struct list_head *tmp;
struct ldlm_lock *lock;
- __u64 req_bits = req->l_policy_data.l_inodebits.bits;
- __u64 *try_bits = &req->l_policy_data.l_inodebits.try_bits;
+ enum mds_ibits_locks req_bits = req->l_policy_data.l_inodebits.bits;
+ enum mds_ibits_locks *try_bits =
+ &req->l_policy_data.l_inodebits.try_bits;
int compat = 1;
ENTRY;
* Meanwhile that can be true if there were just try_bits and all
* are failed, so just exit gracefully and let the caller to care.
*/
- if ((req_bits | *try_bits) == 0)
+ if ((req_bits | *try_bits) == MDS_INODELOCK_NONE)
RETURN(0);
/* Group lock could be only DOM */
*try_bits &= ~(lock->l_policy_data.l_inodebits.bits |
lock->l_policy_data.l_inodebits.try_bits);
- if ((req_bits | *try_bits) == 0)
+ if ((req_bits | *try_bits) == MDS_INODELOCK_NONE)
RETURN(0);
/* The new lock ibits is more preferable than try_bits
RETURN(LDLM_ITER_STOP);
/* grant also try_bits if any */
- if (lock->l_policy_data.l_inodebits.try_bits != 0) {
+ if (lock->l_policy_data.l_inodebits.try_bits !=
+ MDS_INODELOCK_NONE) {
lock->l_policy_data.l_inodebits.bits |=
lock->l_policy_data.l_inodebits.try_bits;
- lock->l_policy_data.l_inodebits.try_bits = 0;
+ lock->l_policy_data.l_inodebits.try_bits =
+ MDS_INODELOCK_NONE;
*ldlm_flags |= LDLM_FL_LOCK_CHANGED;
}
ldlm_resource_unlink_lock(lock);
}
} else {
/* grant also all remaining try_bits */
- if (lock->l_policy_data.l_inodebits.try_bits != 0) {
+ if (lock->l_policy_data.l_inodebits.try_bits !=
+ MDS_INODELOCK_NONE) {
lock->l_policy_data.l_inodebits.bits |=
lock->l_policy_data.l_inodebits.try_bits;
- lock->l_policy_data.l_inodebits.try_bits = 0;
+ lock->l_policy_data.l_inodebits.try_bits =
+ MDS_INODELOCK_NONE;
*ldlm_flags |= LDLM_FL_LOCK_CHANGED;
}
LASSERT(lock->l_policy_data.l_inodebits.bits);
* Such lock conversion is used to keep lock with non-blocking bits instead of
* cancelling it, introduced for better support of DoM files.
*/
-int ldlm_inodebits_drop(struct ldlm_lock *lock, __u64 to_drop)
+int ldlm_inodebits_drop(struct ldlm_lock *lock, enum mds_ibits_locks to_drop)
{
ENTRY;
check_res_locked(lock->l_resource);
/* Just return if there are no conflicting bits */
- if ((lock->l_policy_data.l_inodebits.bits & to_drop) == 0) {
- LDLM_WARN(lock, "try to drop unset bits %#llx/%#llx",
+ if ((lock->l_policy_data.l_inodebits.bits & to_drop) ==
+ MDS_INODELOCK_NONE) {
+ LDLM_WARN(lock, "try to drop unset bits %#lx/%#lx",
lock->l_policy_data.l_inodebits.bits, to_drop);
/* nothing to do */
RETURN(0);
{
struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
struct ldlm_lock_desc ld = { { 0 } };
- __u64 drop_bits, new_bits;
+ enum mds_ibits_locks drop_bits, new_bits;
__u32 flags = 0;
int rc;
drop_bits = lock->l_policy_data.l_inodebits.cancel_bits;
/* no cancel bits - means that caller needs full cancel */
- if (drop_bits == 0)
+ if (drop_bits == MDS_INODELOCK_NONE)
RETURN(-EINVAL);
new_bits = lock->l_policy_data.l_inodebits.bits & ~drop_bits;
* it will result in another cycle of ldlm_cli_inodebits_convert().
*/
full_cancel:
- lock->l_policy_data.l_inodebits.cancel_bits = 0;
+ lock->l_policy_data.l_inodebits.cancel_bits = MDS_INODELOCK_NONE;
clear_converting:
ldlm_clear_converting(lock);
RETURN(rc);
#ifdef HAVE_SERVER_SUPPORT
int ldlm_reprocess_queue(struct ldlm_resource *res, struct list_head *queue,
struct list_head *work_list,
- enum ldlm_process_intention intention, __u64 hint);
+ enum ldlm_process_intention intention,
+ enum mds_ibits_locks hint);
int ldlm_handle_conflict_lock(struct ldlm_lock *lock, __u64 *flags,
struct list_head *rpc_list);
void ldlm_discard_bl_list(struct list_head *bl_list);
struct list_head *queue,
struct list_head *work_list,
enum ldlm_process_intention intention,
- __u64 hint);
+ enum mds_ibits_locks hint);
/* ldlm_extent.c */
int ldlm_process_extent_lock(struct ldlm_lock *lock, __u64 *flags,
enum ldlm_process_intention intention,
bool ret = 0;
lock_res_and_lock(lock);
- ret = (lock->l_policy_data.l_inodebits.cancel_bits == 0);
+ ret = (lock->l_policy_data.l_inodebits.cancel_bits ==
+ MDS_INODELOCK_NONE);
unlock_res_and_lock(lock);
return ret;
EXPORT_SYMBOL(ldlm_lock_match_with_skip);
enum ldlm_mode ldlm_revalidate_lock_handle(const struct lustre_handle *lockh,
- __u64 *bits)
+ enum mds_ibits_locks *bits)
{
struct ldlm_lock *lock;
enum ldlm_mode mode = 0;
*/
int ldlm_reprocess_queue(struct ldlm_resource *res, struct list_head *queue,
struct list_head *work_list,
- enum ldlm_process_intention intention, __u64 hint)
+ enum ldlm_process_intention intention,
+ enum mds_ibits_locks hint)
{
struct list_head *tmp, *pos;
ldlm_processing_policy policy;
*/
static void __ldlm_reprocess_all(struct ldlm_resource *res,
enum ldlm_process_intention intention,
- __u64 hint)
+ enum mds_ibits_locks hint)
{
LIST_HEAD(rpc_list);
#ifdef HAVE_SERVER_SUPPORT
EXIT;
}
-void ldlm_reprocess_all(struct ldlm_resource *res, __u64 hint)
+void ldlm_reprocess_all(struct ldlm_resource *res, enum mds_ibits_locks hint)
{
__ldlm_reprocess_all(res, LDLM_PROCESS_RESCAN, hint);
}
case LDLM_IBITS:
if (!lock->l_remote_handle.cookie)
libcfs_debug_msg(msgdata,
- "%pV ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s res: " DLDLMRES " bits %#llx/%#llx rrc: %d type: %s flags: %#llx pid: %u initiator: MDT%d\n",
+ "%pV ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s res: " DLDLMRES " bits %#lx/%#lx rrc: %d type: %s flags: %#llx pid: %u initiator: MDT%d\n",
&vaf,
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
lock->l_policy_data.l_inodebits.li_initiator_id);
else
libcfs_debug_msg(msgdata,
- "%pV ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s res: " DLDLMRES " bits %#llx/%#llx rrc: %d type: %s gid %llu flags: %#llx nid: %s remote: %#llx expref: %d pid: %u timeout: %lld lvb_type: %d\n",
+ "%pV ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s res: " DLDLMRES " bits %#lx/%#lx rrc: %d type: %s gid %llu flags: %#llx nid: %s remote: %#llx expref: %d pid: %u timeout: %lld lvb_type: %d\n",
&vaf,
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
struct ldlm_lock_desc *rep_desc = &dlm_rep->lock_desc;
LDLM_DEBUG(lock,
- "save blocking bits %llx in granted lock",
+ "save blocking bits %lx in granted lock",
bl_lock->l_policy_data.l_inodebits.bits);
/*
* If lock is blocked then save blocking ibits
struct obd_export *exp = req->rq_export;
struct ldlm_reply *dlm_rep;
struct ldlm_lock *lock;
- __u64 bits;
- __u64 new_bits;
+ enum mds_ibits_locks bits;
+ enum mds_ibits_locks new_bits;
int rc;
ENTRY;
ldlm_del_waiting_lock(lock);
ldlm_clear_cbpending(lock);
- lock->l_policy_data.l_inodebits.cancel_bits = 0;
+ lock->l_policy_data.l_inodebits.cancel_bits =
+ MDS_INODELOCK_NONE;
ldlm_inodebits_drop(lock, bits & ~new_bits);
ldlm_clear_blocking_data(lock);
ldlm_res_eq(&ld->l_resource.lr_name,
&lock->l_resource->lr_name) &&
!(ldlm_is_cbpending(lock) &&
- lock->l_policy_data.l_inodebits.cancel_bits == 0)) {
+ lock->l_policy_data.l_inodebits.cancel_bits ==
+ MDS_INODELOCK_NONE)) {
/* always combine conflicting ibits */
lock->l_policy_data.l_inodebits.cancel_bits |=
ld->l_policy_data.l_inodebits.cancel_bits;
* has no cancel_bits set
* - the full lock is to be cancelled
*/
- lock->l_policy_data.l_inodebits.cancel_bits = 0;
+ lock->l_policy_data.l_inodebits.cancel_bits =
+ MDS_INODELOCK_NONE;
}
}
}
body->lock_desc.l_granted_mode = lock->l_granted_mode;
body->lock_desc.l_policy_data.l_inodebits.bits = new_bits;
- body->lock_desc.l_policy_data.l_inodebits.cancel_bits = 0;
+ body->lock_desc.l_policy_data.l_inodebits.cancel_bits =
+ MDS_INODELOCK_NONE;
body->lock_flags = ldlm_flags_to_wire(*flags);
body->lock_count = 1;
struct lu_fid *fid, bool locked);
int lfsck_ibits_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
struct dt_object *obj, struct lustre_handle *lh,
- __u64 bits, enum ldlm_mode mode);
+ enum mds_ibits_locks bits, enum ldlm_mode mode);
void lfsck_ibits_unlock(struct lustre_handle *lh, enum ldlm_mode mode);
int lfsck_remote_lookup_lock(const struct lu_env *env,
struct lfsck_instance *lfsck,
struct lustre_handle *lh, enum ldlm_mode mode);
int lfsck_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
struct dt_object *obj, const char *name,
- struct lfsck_lock_handle *llh, __u64 bits, enum ldlm_mode mode);
+ struct lfsck_lock_handle *llh, enum mds_ibits_locks bits,
+ enum ldlm_mode mode);
void lfsck_unlock(struct lfsck_lock_handle *llh);
int lfsck_find_mdt_idx_by_fid(const struct lu_env *env,
struct lfsck_instance *lfsck,
static int __lfsck_ibits_lock(const struct lu_env *env,
struct lfsck_instance *lfsck,
struct dt_object *obj, struct ldlm_res_id *resid,
- struct lustre_handle *lh, __u64 bits,
- enum ldlm_mode mode)
+ struct lustre_handle *lh,
+ enum mds_ibits_locks bits, enum ldlm_mode mode)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
union ldlm_policy_data *policy = &info->lti_policy;
*/
int lfsck_ibits_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
struct dt_object *obj, struct lustre_handle *lh,
- __u64 bits, enum ldlm_mode mode)
+ enum mds_ibits_locks bits, enum ldlm_mode mode)
{
struct ldlm_res_id *resid = &lfsck_env_info(env)->lti_resid;
*/
int lfsck_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
struct dt_object *obj, const char *name,
- struct lfsck_lock_handle *llh, __u64 bits, enum ldlm_mode mode)
+ struct lfsck_lock_handle *llh, enum mds_ibits_locks bits,
+ enum ldlm_mode mode)
{
struct ldlm_res_id *resid = &lfsck_env_info(env)->lti_resid;
int rc;
struct dentry *de)
{
struct inode *inode = de->d_inode;
- __u64 bits = 0;
+ enum mds_ibits_locks bits = MDS_INODELOCK_NONE;
int rc = 0;
ENTRY;
rc = ll_prep_inode(&de->d_inode, &req->rq_pill, NULL, itp);
if (!rc && itp->it_lock_mode) {
- __u64 bits = 0;
+ enum mds_ibits_locks bits = MDS_INODELOCK_NONE;
/* if DoM bit returned along with LAYOUT bit then there
* can be read-on-open data returned.
!(it.it_lock_bits & MDS_INODELOCK_OPEN)) {
/* open lock must return for lease */
rc = -EPROTO;
- CERROR("%s: "DFID" lease granted but no open lock, %d/%llu: rc = %d\n",
+ CERROR("%s: "DFID" lease granted but no open lock, %d/%lu: rc = %d\n",
sbi->ll_fsname, PFID(ll_inode2fid(inode)),
it.it_lock_mode, it.it_lock_bits, rc);
GOTO(out_close, rc);
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 & BIT(i);
- if (policy.l_inodebits.bits == 0)
+ if (policy.l_inodebits.bits == MDS_INODELOCK_NONE)
continue;
if (md_lock_match(exp, flags, fid, LDLM_IBITS, &policy, mode,
}
static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode,
- struct lookup_intent *it, __u64 *bits)
+ struct lookup_intent *it,
+ enum mds_ibits_locks *bits)
{
if (!it->it_lock_set) {
struct lustre_handle handle;
static int ll_md_need_convert(struct ldlm_lock *lock)
{
struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
- __u64 wanted = lock->l_policy_data.l_inodebits.cancel_bits;
+ enum mds_ibits_locks want = lock->l_policy_data.l_inodebits.cancel_bits;
enum ldlm_mode mode = LCK_MODE_MIN;
enum mds_ibits_locks bits;
struct inode *inode;
!exp_connect_lock_convert(lock->l_conn_export))
return 0;
- bits = lock->l_policy_data.l_inodebits.bits & ~wanted;
- if (!wanted || !bits || ldlm_is_cancel(lock))
+ bits = lock->l_policy_data.l_inodebits.bits & ~want;
+ if (!want || !bits || ldlm_is_cancel(lock))
return 0;
/* do not convert locks other than DOM for now */
- if (!((bits | wanted) & MDS_INODELOCK_DOM))
+ if (!((bits | want) & MDS_INODELOCK_DOM))
return 0;
/* We may have already remaining bits in some other lock so
struct md_op_data *op_data,
ktime_t kstart, bool encrypt)
{
- struct inode *inode = NULL;
- __u64 bits = 0;
- int rc;
+ enum mds_ibits_locks bits = MDS_INODELOCK_NONE;
+ struct inode *inode = NULL;
struct dentry *alias;
+ int rc;
ENTRY;
bool encrypt, unsigned int open_flags)
{
struct inode *inode;
- __u64 bits = 0;
+ enum mds_ibits_locks bits = MDS_INODELOCK_NONE;
int rc = 0;
ENTRY;
GOTO(out_fini, rc);
if (mkdir_it.it_lock_mode) {
- __u64 bits = 0;
+ enum mds_ibits_locks bits = MDS_INODELOCK_NONE;
LASSERT(it_disposition(&mkdir_it, DISP_LOOKUP_NEG));
ll_set_lock_data(sbi->ll_md_exp, inode, &mkdir_it, &bits);
struct lookup_intent it = { .it_op = IT_GETATTR,
.it_lock_handle =
entry->se_handle };
- __u64 bits;
+ enum mds_ibits_locks bits;
rc = md_revalidate_lock(ll_i2mdexp(dir), &it,
ll_inode2fid(inode), &bits);
static int lmv_early_cancel(struct obd_export *exp, struct lmv_tgt_desc *tgt,
struct md_op_data *op_data, __u32 op_tgt,
- enum ldlm_mode mode, int bits, int flag)
+ enum ldlm_mode mode, enum mds_ibits_locks bits,
+ int flag)
{
struct lu_fid *fid = md_op_data_fid(op_data, flag);
struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
static int lmv_set_lock_data(struct obd_export *exp,
const struct lustre_handle *lockh,
- void *data, __u64 *bits)
+ void *data, enum mds_ibits_locks *bits)
{
struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
}
static int lmv_revalidate_lock(struct obd_export *exp, struct lookup_intent *it,
- struct lu_fid *fid, __u64 *bits)
+ struct lu_fid *fid, enum mds_ibits_locks *bits)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
/* mdc/mdc_locks.c */
int mdc_set_lock_data(struct obd_export *exp,
const struct lustre_handle *lockh,
- void *data, __u64 *bits);
+ void *data, enum mds_ibits_locks *bits);
int mdc_null_inode(struct obd_export *exp, const struct lu_fid *fid);
enum ldlm_cancel_flags flags, void *opaque);
int mdc_revalidate_lock(struct obd_export *exp, struct lookup_intent *it,
- struct lu_fid *fid, __u64 *bits);
+ struct lu_fid *fid, enum mds_ibits_locks *bits);
int mdc_intent_getattr_async(struct obd_export *exp, struct md_op_item *item);
/* this must be called on a lockh that is known to have a referenced lock */
int mdc_set_lock_data(struct obd_export *exp, const struct lustre_handle *lockh,
- void *data, __u64 *bits)
+ void *data, enum mds_ibits_locks *bits)
{
struct ldlm_lock *lock;
struct inode *new_inode = data;
}
int mdc_revalidate_lock(struct obd_export *exp, struct lookup_intent *it,
- struct lu_fid *fid, __u64 *bits)
+ struct lu_fid *fid, enum mds_ibits_locks *bits)
{
/* We could just return 1 immediately, but as we should only be called
* in revalidate_it if we already have a lock, let's verify that.
*/
static int mdt_getattr_name_lock(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc,
- __u64 child_bits,
+ enum mds_ibits_locks child_bits,
struct ldlm_reply *ldlm_rep)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct ldlm_lock *lock;
struct req_capsule *pill = info->mti_pill;
bool fscrypt_md = false;
- __u64 try_bits = 0;
+ enum mds_ibits_locks try_bits = MDS_INODELOCK_NONE;
bool is_resent;
int ma_need = 0;
int rc;
child_bits = 0;
}
- if (try_bits != 0) {
+ if (try_bits != MDS_INODELOCK_NONE) {
/* try layout lock, it may fail to be granted due to
* contention at LOOKUP or UPDATE
*/
return -ENOTDIR;
policy->l_inodebits.bits = MDS_INODELOCK_UPDATE;
- policy->l_inodebits.try_bits = 0;
+ policy->l_inodebits.try_bits = MDS_INODELOCK_NONE;
policy->l_inodebits.li_gid = 0;
policy->l_inodebits.li_initiator_id = mdt_node_id(info->mti_mdt);
fid_build_reg_res_name(mdt_object_fid(obj), res_id);
int mdt_object_lock_internal(struct mdt_thread_info *info,
struct mdt_object *obj, const struct lu_fid *fid,
- struct mdt_lock_handle *lh, __u64 *ibits,
- __u64 trybits, bool cache)
+ struct mdt_lock_handle *lh,
+ enum mds_ibits_locks *ibits,
+ enum mds_ibits_locks trybits,
+ bool cache)
{
union ldlm_policy_data *policy = &info->mti_policy;
struct ldlm_res_id *res_id = &info->mti_res_id;
* \retval 0 on success, -ev on error.
*/
int mdt_object_lock(struct mdt_thread_info *info, struct mdt_object *obj,
- struct mdt_lock_handle *lh, __u64 ibits,
+ struct mdt_lock_handle *lh, enum mds_ibits_locks ibits,
enum ldlm_mode mode)
{
int rc;
*/
int mdt_object_check_lock(struct mdt_thread_info *info,
struct mdt_object *parent, struct mdt_object *child,
- struct mdt_lock_handle *lh, __u64 ibits,
- enum ldlm_mode mode)
+ struct mdt_lock_handle *lh,
+ enum mds_ibits_locks ibits, enum ldlm_mode mode)
{
int rc;
mdt_lock_reg_init(lh, mode);
if (mdt_object_remote(parent) ^ mdt_object_remote(child)) {
- __u64 lookup_ibits = MDS_INODELOCK_LOOKUP;
+ enum mds_ibits_locks lookup_ibits = MDS_INODELOCK_LOOKUP;
rc = mdt_object_lock_internal(info, parent,
mdt_object_fid(child), lh,
LASSERT(obj && lname);
LASSERT(mode == LCK_PW || mode == LCK_PR);
if (mdt_object_remote(obj) && mode == LCK_PR) {
- __u64 ibits = MDS_INODELOCK_UPDATE;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_UPDATE;
mdt_lock_reg_init(lh, mode);
rc = mdt_object_lock_internal(info, obj, mdt_object_fid(obj),
* \retval 0 on success, -ev on error.
*/
int mdt_object_lock_try(struct mdt_thread_info *info, struct mdt_object *obj,
- struct mdt_lock_handle *lh, __u64 *ibits,
- __u64 trybits, enum ldlm_mode mode)
+ struct mdt_lock_handle *lh, enum mds_ibits_locks *ibits,
+ enum mds_ibits_locks trybits, enum ldlm_mode mode)
{
bool trylock_only = *ibits == 0;
int rc;
struct mdt_object *pobj, struct mdt_object *obj,
struct mdt_lock_handle *lh, enum ldlm_mode mode)
{
- __u64 ibits = MDS_INODELOCK_LOOKUP;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_LOOKUP;
int rc;
ENTRY;
struct mdt_object *mdt_object_find_lock(struct mdt_thread_info *info,
const struct lu_fid *f,
struct mdt_lock_handle *lh,
- __u64 ibits, enum ldlm_mode mode)
+ enum mds_ibits_locks ibits,
+ enum ldlm_mode mode)
{
struct mdt_object *o;
struct mdt_lock_handle *lhc);
int mdt_object_lock(struct mdt_thread_info *info, struct mdt_object *obj,
- struct mdt_lock_handle *lh, __u64 ibits,
+ struct mdt_lock_handle *lh, enum mds_ibits_locks ibits,
enum ldlm_mode mode);
int mdt_parent_lock(struct mdt_thread_info *info, struct mdt_object *o,
struct mdt_lock_handle *lh, const struct lu_name *lname,
int mdt_object_stripes_lock(struct mdt_thread_info *info,
struct mdt_object *pobj, struct mdt_object *o,
struct mdt_lock_handle *lh,
- struct ldlm_enqueue_info *einfo, __u64 ibits,
+ struct ldlm_enqueue_info *einfo,
+ enum mds_ibits_locks ibits,
enum ldlm_mode mode);
int mdt_object_check_lock(struct mdt_thread_info *info,
struct mdt_object *parent, struct mdt_object *child,
- struct mdt_lock_handle *lh, __u64 ibits,
- enum ldlm_mode mode);
+ struct mdt_lock_handle *lh,
+ enum mds_ibits_locks ibits, enum ldlm_mode mode);
int mdt_object_lock_try(struct mdt_thread_info *info, struct mdt_object *mo,
- struct mdt_lock_handle *lh, __u64 *ibits,
- __u64 trybits, enum ldlm_mode mode);
+ struct mdt_lock_handle *lh,
+ enum mds_ibits_locks *ibits,
+ enum mds_ibits_locks trybits, enum ldlm_mode mode);
/* below three lock functions are used internally */
int mdt_object_lock_internal(struct mdt_thread_info *info,
struct mdt_object *obj, const struct lu_fid *fid,
- struct mdt_lock_handle *lh, __u64 *ibits,
- __u64 trybits, bool cache);
+ struct mdt_lock_handle *lh,
+ enum mds_ibits_locks *ibits,
+ enum mds_ibits_locks trybits,
+ bool cache);
int mdt_object_pdo_lock(struct mdt_thread_info *info, struct mdt_object *obj,
struct mdt_lock_handle *lh, const struct lu_name *name,
enum ldlm_mode mode, bool pdo_lock);
struct mdt_object *mdt_object_find_lock(struct mdt_thread_info *info,
const struct lu_fid *f,
struct mdt_lock_handle *lh,
- __u64 ibits, enum ldlm_mode mode);
+ enum mds_ibits_locks ibits,
+ enum ldlm_mode mode);
void mdt_object_unlock_put(struct mdt_thread_info *info,
struct mdt_object *o,
struct mdt_lock_handle *lh,
mdt_intent_fixup_resent(mti, *lockp, lhc, flags);
/* resent case */
if (!lustre_handle_is_used(&lhc->mlh_reg_lh)) {
- __u64 ibits = MDS_INODELOCK_DOM;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_DOM;
mdt_lh_reg_init(lhc, *lockp);
RETURN_EXIT;
policy.l_inodebits.bits = MDS_INODELOCK_DOM;
- policy.l_inodebits.try_bits = 0;
+ policy.l_inodebits.try_bits = MDS_INODELOCK_NONE;
policy.l_inodebits.li_initiator_id = mdt_node_id(mdt);
fid_build_reg_res_name(mdt_object_fid(mo), &res_id);
static int mdt_object_open_lock(struct mdt_thread_info *info,
struct mdt_object *obj,
struct mdt_lock_handle *lhc,
- __u64 *ibits)
+ enum mds_ibits_locks *ibits)
{
struct md_attr *ma = &info->mti_attr;
enum mds_open_flags open_flags = info->mti_spec.sp_cr_flags;
- __u64 trybits = 0;
+ enum mds_ibits_locks trybits = MDS_INODELOCK_NONE;
enum ldlm_mode lm = LCK_PR;
bool acq_lease = !!(open_flags & MDS_OPEN_LEASE);
bool try_layout = false;
struct ptlrpc_request *req = mdt_info_req(info);
ENTRY;
- *ibits = 0;
+ *ibits = MDS_INODELOCK_NONE;
if (req_is_replay(mdt_info_req(info)))
RETURN(0);
/* Lease must be with open lock */
if (!(open_flags & MDS_OPEN_LOCK)) {
- CERROR("%s: Request lease for file:"DFID ", but open lock "
- "is missed, open_flags = %#lo : rc = %d\n",
+ CERROR("%s: Request lease for file:"DFID ", but open lock is missed, open_flags = %#lo : rc = %d\n",
mdt_obd_name(info->mti_mdt),
PFID(mdt_object_fid(obj)), open_flags, -EPROTO);
GOTO(out, rc = -EPROTO);
if (*ibits | trybits)
rc = mdt_object_lock_try(info, obj, lhc, ibits, trybits, lm);
- CDEBUG(D_INODE, "%s: Requested bits lock:"DFID ", ibits = %#llx/%#llx"
- ", open_flags = %#lo, try_layout = %d : rc = %d\n",
+ CDEBUG(D_INODE,
+ "%s: Requested bits lock:"DFID ", ibits = %#lx/%#lx, open_flags = %#lo, try_layout = %d : rc = %d\n",
mdt_obd_name(info->mti_mdt), PFID(mdt_object_fid(obj)),
*ibits, trybits, open_flags, try_layout, rc);
static void mdt_object_open_unlock(struct mdt_thread_info *info,
struct mdt_object *obj,
struct mdt_lock_handle *lhc,
- __u64 ibits, int rc)
+ enum mds_ibits_locks ibits, int rc)
{
enum mds_open_flags open_flags = info->mti_spec.sp_cr_flags;
struct mdt_lock_handle *ll = &info->mti_lh[MDT_LH_LOCAL];
up_read(&obj->mot_open_sem);
/* Cross-ref case, the lock should be returned to the client */
- if (ibits == 0 || rc == -MDT_EREMOTE_OPEN)
+ if (ibits == MDS_INODELOCK_NONE || rc == -MDT_EREMOTE_OPEN)
RETURN_EXIT;
if (!(open_flags & MDS_OPEN_LOCK) &&
static int mdt_refetch_lovea(struct mdt_thread_info *info,
struct mdt_object *o, struct md_attr *ma,
- u64 ibits)
+ enum mds_ibits_locks ibits)
{
struct mdt_body *repbody;
int rc;
struct mdt_object *parent = NULL;
struct mdt_object *o;
bool object_locked = false;
- u64 ibits = 0;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_NONE;
int rc;
ENTRY;
{
struct mdt_object *md_root = mdt->mdt_md_root;
struct mdt_lock_handle *lh = &info->mti_lh[MDT_LH_LOCAL];
- __u64 ibits = MDS_INODELOCK_XATTR;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_XATTR;
int rc;
if (md_root == NULL) {
struct lu_ucred *uc = mdt_ucred(info);
struct md_attr *ma = &info->mti_attr;
enum mds_open_flags open_flags = info->mti_spec.sp_cr_flags;
- u64 ibits = 0;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_NONE;
struct mdt_reint_record *rr = &info->mti_rr;
int result, rc;
int created = 0;
* will be stored in einfo->ei_cbdata.
**/
static int mdt_stripes_lock(struct mdt_thread_info *mti, struct mdt_object *obj,
- enum ldlm_mode mode, __u64 ibits,
+ enum ldlm_mode mode, enum mds_ibits_locks ibits,
struct ldlm_enqueue_info *einfo)
{
union ldlm_policy_data *policy = &mti->mti_policy;
struct mdt_object *parent,
struct mdt_object *child,
struct mdt_lock_handle *lh,
- struct ldlm_enqueue_info *einfo, __u64 ibits,
+ struct ldlm_enqueue_info *einfo,
+ enum mds_ibits_locks ibits,
enum ldlm_mode mode)
{
int rc;
struct mdt_lock_handle *lh;
int do_vbr = ma->ma_attr.la_valid &
(LA_MODE | LA_UID | LA_GID | LA_PROJID | LA_FLAGS);
- __u64 lockpart = MDS_INODELOCK_UPDATE;
+ enum mds_ibits_locks lockpart = MDS_INODELOCK_UPDATE;
struct ldlm_enqueue_info *einfo = &info->mti_einfo;
int rc;
static int mdt_rename_lock(struct mdt_thread_info *info,
struct mdt_lock_handle *lh)
{
+ enum mds_ibits_locks ibits = MDS_INODELOCK_UPDATE;
struct lu_fid *fid = &info->mti_tmp_fid1;
struct mdt_object *obj;
- __u64 ibits = MDS_INODELOCK_UPDATE;
int rc;
ENTRY;
struct mdt_object *child,
struct mdt_lock_handle *lh,
struct mdt_lock_handle *lh_lookup,
- __u64 ibits)
+ enum mds_ibits_locks ibits)
{
int rc;
const struct lu_fid *fid = mdt_object_fid(lnkp);
struct mdt_lock_handle *lhl = &info->mti_lh[MDT_LH_LOCAL];
struct mdt_link_lock *entry;
- __u64 ibits = 0;
+ enum mds_ibits_locks ibits = MDS_INODELOCK_NONE;
int rc;
ENTRY;
__u64 valid = attr->la_valid;
const char *xattr_name = rr->rr_name.ln_name;
int xattr_len = rr->rr_eadatalen;
- __u64 lockpart = MDS_INODELOCK_UPDATE;
+ enum mds_ibits_locks lockpart = MDS_INODELOCK_UPDATE;
ktime_t kstart = ktime_get();
int rc;
ENTRY;
if (flags & OBD_CONNECT_BRW_SIZE)
seq_printf(m, " max_brw_size: %d\n", ocd->ocd_brw_size);
if (flags & OBD_CONNECT_IBITS)
- seq_printf(m, " ibits_known: %#llx\n",
+ seq_printf(m, " ibits_known: %#lx\n",
ocd->ocd_ibits_known);
if (flags & OBD_CONNECT_GRANT_PARAM)
seq_printf(m, " grant_block_size: %d\n"
__swab64s(&ocd->ocd_connect_flags);
__swab32s(&ocd->ocd_version);
__swab32s(&ocd->ocd_grant);
- __swab64s(&ocd->ocd_ibits_known);
+ __swab64s((__u64 *)&ocd->ocd_ibits_known);
__swab32s(&ocd->ocd_index);
__swab32s(&ocd->ocd_brw_size);
/*
if (unlikely(dlm_req->lock_desc.l_resource.lr_type ==
LDLM_IBITS &&
(policy->l_inodebits.bits |
- policy->l_inodebits.try_bits) == 0)) {
+ policy->l_inodebits.try_bits) ==
+ MDS_INODELOCK_NONE)) {
/*
* Lock without inodebits makes no sense and
* will oops later in ldlm. If client miss to
git://git.whamcloud.com / fs / lustre-release.git / commitdiff