X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flinux%2Flustre_dlm.h;h=4324ee28f76746f9c26bb389ca62dd8b62a64524;hb=69b292d708e6d12e0849ee1293dded75a6e54d0b;hp=9d8ee98f38d0cf589c89c0fd5ecad3286c82b4f7;hpb=7ec93168ad1a12925ebc0c3f35c0b3dcdb755131;p=fs%2Flustre-release.git diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h index 9d8ee98..4324ee2 100644 --- a/lustre/include/linux/lustre_dlm.h +++ b/lustre/include/linux/lustre_dlm.h @@ -7,27 +7,41 @@ #ifdef __KERNEL__ -#include +#include +#include #include +#include -#define OBD_LDLM_DEVICENAME "ldlm" +struct obd_ops; +struct obd_device; -typedef int cluster_host; -typedef int cluster_pid; +#define OBD_LDLM_DEVICENAME "ldlm" typedef enum { ELDLM_OK = 0, ELDLM_LOCK_CHANGED = 300, + ELDLM_LOCK_ABORTED = 301, ELDLM_NAMESPACE_EXISTS = 400, ELDLM_BAD_NAMESPACE = 401 } ldlm_error_t; +#define LDLM_NAMESPACE_SERVER 0 +#define LDLM_NAMESPACE_CLIENT 1 + #define LDLM_FL_LOCK_CHANGED (1 << 0) #define LDLM_FL_BLOCK_GRANTED (1 << 1) #define LDLM_FL_BLOCK_CONV (1 << 2) #define LDLM_FL_BLOCK_WAIT (1 << 3) +#define LDLM_FL_CBPENDING (1 << 4) +#define LDLM_FL_AST_SENT (1 << 5) +#define LDLM_FL_DESTROYED (1 << 6) +#define LDLM_FL_WAIT_NOREPROC (1 << 7) +#define LDLM_FL_CANCEL (1 << 8) + +#define LDLM_CB_BLOCKING 1 +#define LDLM_CB_CANCELING 2 #define L2B(c) (1 << c) @@ -58,33 +72,38 @@ static inline int lockmode_compat(ldlm_mode_t exist, ldlm_mode_t new) return (lck_compat_array[exist] & L2B(new)); } -/* - * - * cluster name spaces +/* + * + * cluster name spaces * */ #define DLM_OST_NAMESPACE 1 #define DLM_MDS_NAMESPACE 2 -/* XXX - - do we just separate this by security domains and use a prefix for - multiple namespaces in the same domain? - - +/* XXX + - do we just separate this by security domains and use a prefix for + multiple namespaces in the same domain? + - */ struct ldlm_namespace { - struct list_head ns_link; /* in the list of ns's */ - __u32 ns_id; /* identifier of ns */ - struct list_head *ns_hash; /* hash table for ns */ - atomic_t ns_refcount; /* count of resources in the hash */ - struct list_head ns_root_list; /* all root resources in ns */ - struct obd_device *ns_obddev; + char *ns_name; + __u32 ns_client; /* is this a client-side lock tree? */ + struct list_head *ns_hash; /* hash table for ns */ + __u32 ns_refcount; /* count of resources in the hash */ + struct list_head ns_root_list; /* all root resources in ns */ + struct list_head ns_list_chain; /* position in global NS list */ + struct proc_dir_entry *ns_proc_dir; + + spinlock_t ns_counter_lock; + __u64 ns_locks; + __u64 ns_resources; }; -/* - * - * Resource hash table +/* + * + * Resource hash table * */ @@ -94,63 +113,98 @@ struct ldlm_namespace { struct ldlm_lock; -typedef int (*ldlm_lock_callback)(struct ldlm_lock *lock, struct ldlm_lock *new, - void *data, __u32 data_len); +typedef int (*ldlm_blocking_callback)(struct ldlm_lock *lock, + struct ldlm_lock_desc *new, void *data, + __u32 data_len, int flag); + +typedef int (*ldlm_completion_callback)(struct ldlm_lock *lock, int flags); struct ldlm_lock { + __u64 l_random; + int l_refc; struct ldlm_resource *l_resource; struct ldlm_lock *l_parent; struct list_head l_children; struct list_head l_childof; struct list_head l_res_link; /*position in one of three res lists*/ + struct list_head l_export_chain; /* per-export chain of locks */ + struct list_head l_pending_chain; /* locks with callbacks pending*/ + unsigned long l_callback_timeout; + ldlm_mode_t l_req_mode; ldlm_mode_t l_granted_mode; - ldlm_lock_callback l_completion_ast; - ldlm_lock_callback l_blocking_ast; - struct ptlrpc_connection *l_connection; + + ldlm_completion_callback l_completion_ast; + ldlm_blocking_callback l_blocking_ast; + + struct obd_export *l_export; + struct lustre_handle *l_connh; + __u32 l_flags; + struct lustre_handle l_remote_handle; void *l_data; __u32 l_data_len; + void *l_cookie; + int l_cookie_len; struct ldlm_extent l_extent; - struct ldlm_handle l_remote_handle; - //void *l_event; - //XXX cluster_host l_holder; __u32 l_version[RES_VERSION_SIZE]; + + __u32 l_readers; + __u32 l_writers; + + /* If the lock is granted, a process sleeps on this waitq to learn when + * it's no longer in use. If the lock is not granted, a process sleeps + * on this waitq to learn when it becomes granted. */ wait_queue_head_t l_waitq; }; typedef int (*ldlm_res_compat)(struct ldlm_lock *child, struct ldlm_lock *new); -typedef int (*ldlm_res_policy)(struct ldlm_resource *parent, - struct ldlm_extent *req_ex, - struct ldlm_extent *new_ex, +typedef int (*ldlm_res_policy)(struct ldlm_lock *lock, void *req_cookie, ldlm_mode_t mode, void *data); -#define LDLM_PLAIN 0x0 -#define LDLM_EXTENT 0x1 -#define LDLM_MDSINTENT 0x2 +#define LDLM_PLAIN 10 +#define LDLM_EXTENT 11 +#define LDLM_MDSINTENT 12 + +#define LDLM_MIN_TYPE 10 +#define LDLM_MAX_TYPE 12 -#define LDLM_MAX_TYPE 0x2 -extern ldlm_res_compat ldlm_res_compat_table []; -extern ldlm_res_policy ldlm_res_policy_table []; +extern ldlm_res_compat ldlm_res_compat_table []; +extern ldlm_res_policy ldlm_res_policy_table []; struct ldlm_resource { struct ldlm_namespace *lr_namespace; struct list_head lr_hash; - struct list_head lr_rootlink; /* link all root resources in NS */ struct ldlm_resource *lr_parent; /* 0 for a root resource */ struct list_head lr_children; /* list head for child resources */ - struct list_head lr_childof; /* part of child list of parent */ + struct list_head lr_childof; /* part of ns_root_list if root res, + * part of lr_children if child */ struct list_head lr_granted; struct list_head lr_converting; struct list_head lr_waiting; ldlm_mode_t lr_most_restr; - atomic_t lr_refcount; __u32 lr_type; /* PLAIN, EXTENT, or MDSINTENT */ struct ldlm_resource *lr_root; - //XXX cluster_host lr_master; __u64 lr_name[RES_NAME_SIZE]; __u32 lr_version[RES_VERSION_SIZE]; - spinlock_t lr_lock; + atomic_t lr_refcount; + void *lr_tmp; +}; + +struct ldlm_ast_work { + struct ldlm_lock *w_lock; + int w_blocking; + struct ldlm_lock_desc w_desc; + struct list_head w_list; + int w_flags; + void *w_data; + int w_datalen; +}; + +/* Per-export ldlm state. */ +struct ldlm_export_data { + struct list_head led_held_locks; + struct obd_import led_import; }; static inline struct ldlm_extent *ldlm_res2extent(struct ldlm_resource *res) @@ -158,101 +212,199 @@ static inline struct ldlm_extent *ldlm_res2extent(struct ldlm_resource *res) return (struct ldlm_extent *)(res->lr_name); } -static inline void *ldlm_handle2object(struct ldlm_handle *handle) -{ - if (handle) - return (void *)(unsigned long)(handle->addr); - return NULL; -} +extern struct obd_ops ldlm_obd_ops; -static inline void ldlm_object2handle(void *object, struct ldlm_handle *handle) -{ - handle->addr = (__u64)(unsigned long)object; -} +extern char *ldlm_lockname[]; +extern char *ldlm_typename[]; +extern char *ldlm_it2str(int it); + +#define LDLM_DEBUG(lock, format, a...) \ +do { \ + if (lock->l_resource == NULL) { \ + CDEBUG(D_DLMTRACE, "### " format \ + " (UNKNOWN: lock %p(rc=%d/%d,%d) mode %s/%s on " \ + "res \?\? (rc=\?\?) type \?\?\? remote "LPX64")\n" \ + , ## a, lock, lock->l_refc, lock->l_readers, \ + lock->l_writers, \ + ldlm_lockname[lock->l_granted_mode], \ + ldlm_lockname[lock->l_req_mode], \ + lock->l_remote_handle.addr); \ + break; \ + } \ + if (lock->l_resource->lr_type == LDLM_EXTENT) { \ + CDEBUG(D_DLMTRACE, "### " format \ + " (%s: lock %p(rc=%d/%d,%d) mode %s/%s on res " \ + LPU64" (rc=%d) type %s ["LPU64"->"LPU64"] remote " \ + LPX64")\n" , ## a, \ + lock->l_resource->lr_namespace->ns_name, lock, \ + lock->l_refc, lock->l_readers, lock->l_writers, \ + ldlm_lockname[lock->l_granted_mode], \ + ldlm_lockname[lock->l_req_mode], \ + lock->l_resource->lr_name[0], \ + atomic_read(&lock->l_resource->lr_refcount), \ + ldlm_typename[lock->l_resource->lr_type], \ + lock->l_extent.start, lock->l_extent.end, \ + lock->l_remote_handle.addr); \ + break; \ + } \ + { \ + CDEBUG(D_DLMTRACE, "### " format \ + " (%s: lock %p(rc=%d/%d,%d) mode %s/%s on res " \ + LPU64" (rc=%d) type %s remote "LPX64")\n" , ## a, \ + lock->l_resource->lr_namespace->ns_name, lock, \ + lock->l_refc, lock->l_readers, lock->l_writers, \ + ldlm_lockname[lock->l_granted_mode], \ + ldlm_lockname[lock->l_req_mode], \ + lock->l_resource->lr_name[0], \ + atomic_read(&lock->l_resource->lr_refcount), \ + ldlm_typename[lock->l_resource->lr_type], \ + lock->l_remote_handle.addr); \ + } \ +} while (0) + +#define LDLM_DEBUG_NOLOCK(format, a...) \ + CDEBUG(D_DLMTRACE, "### " format "\n" , ## a) + +/* For internal LDLM use */ +extern struct lustre_lock ldlm_everything_lock; -extern struct list_head ldlm_namespaces; -extern spinlock_t ldlm_spinlock; +/* ldlm_extent.c */ +int ldlm_extent_compat(struct ldlm_lock *, struct ldlm_lock *); +int ldlm_extent_policy(struct ldlm_lock *, void *, ldlm_mode_t, void *); -static inline void ldlm_lock(void) -{ - spin_lock(&ldlm_spinlock); -} +/* ldlm_lockd.c */ +int ldlm_handle_enqueue(struct ptlrpc_request *req); +int ldlm_handle_convert(struct ptlrpc_request *req); +int ldlm_handle_cancel(struct ptlrpc_request *req); +int ldlm_del_waiting_lock(struct ldlm_lock *lock); -static inline void ldlm_unlock(void) +/* ldlm_lock.c */ +void ldlm_register_intent(int (*arg)(struct ldlm_lock *lock, void *req_cookie, + ldlm_mode_t mode, void *data)); +void ldlm_unregister_intent(void); +void ldlm_lock2handle(struct ldlm_lock *lock, struct lustre_handle *lockh); +struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *, int strict); +void ldlm_lock2handle(struct ldlm_lock *lock, struct lustre_handle *lockh); +void ldlm_cancel_callback(struct ldlm_lock *lock); + +static inline struct ldlm_lock *ldlm_handle2lock(struct lustre_handle *h) { - spin_unlock(&ldlm_spinlock); + return __ldlm_handle2lock(h, 1); } -extern struct obd_ops ldlm_obd_ops; - -/* ldlm_extent.c */ -int ldlm_extent_compat(struct ldlm_lock *, struct ldlm_lock *); -int ldlm_extent_policy(struct ldlm_resource *, struct ldlm_extent *, - struct ldlm_extent *, ldlm_mode_t, void *); - -/* ldlm_lock.c */ -void ldlm_lock_free(struct ldlm_lock *lock); +#define LDLM_LOCK_PUT(lock) \ +do { \ + /*LDLM_DEBUG(lock, "put");*/ \ + ldlm_lock_put(lock); \ +} while (0) + +#define LDLM_LOCK_GET(lock) \ +({ \ + ldlm_lock_get(lock); \ + /*LDLM_DEBUG(lock, "get");*/ \ + lock; \ +}) + +struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock); +void ldlm_lock_put(struct ldlm_lock *lock); +void ldlm_lock_destroy(struct ldlm_lock *lock); void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc); -ldlm_error_t ldlm_local_lock_create(__u32 ns_id, - struct ldlm_handle *parent_lock_handle, - __u64 *res_id, - __u32 type, - struct ldlm_handle *lockh); -ldlm_error_t ldlm_local_lock_enqueue(struct ldlm_handle *lockh, - ldlm_mode_t mode, - struct ldlm_extent *req_ex, - int *flags, - ldlm_lock_callback completion, - ldlm_lock_callback blocking, - void *data, - __u32 data_len); -ldlm_error_t ldlm_local_lock_convert(struct ldlm_handle *lockh, - int new_mode, int *flags); -ldlm_error_t ldlm_local_lock_cancel(struct ldlm_handle *lockh); +void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode); +void ldlm_lock_addref_internal(struct ldlm_lock* , __u32 mode); +void ldlm_lock_decref(struct lustre_handle *lockh, __u32 mode); +void ldlm_grant_lock(struct ldlm_lock *lock); +int ldlm_lock_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type, + void *cookie, int cookielen, ldlm_mode_t mode, + struct lustre_handle *lockh); +struct ldlm_lock * +ldlm_lock_create(struct ldlm_namespace *ns, + struct lustre_handle *parent_lock_handle, + __u64 *res_id, __u32 type, ldlm_mode_t mode, void *data, + __u32 data_len); +ldlm_error_t ldlm_lock_enqueue(struct ldlm_lock *lock, void *cookie, + int cookie_len, int *flags, + ldlm_completion_callback completion, + ldlm_blocking_callback blocking); +struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode, + int *flags); +void ldlm_lock_cancel(struct ldlm_lock *lock); +void ldlm_cancel_locks_for_export(struct obd_export *export); +void ldlm_run_ast_work(struct list_head *rpc_list); +void ldlm_reprocess_all(struct ldlm_resource *res); void ldlm_lock_dump(struct ldlm_lock *lock); /* ldlm_test.c */ -int ldlm_test(struct obd_device *device, struct ptlrpc_connection *conn); +int ldlm_test(struct obd_device *device, struct lustre_handle *connh); +int ldlm_regression_start(struct obd_device *obddev, + struct lustre_handle *connh, + unsigned int threads, unsigned int max_locks_in, + unsigned int num_resources_in, + unsigned int num_extents_in); +int ldlm_regression_stop(void); + /* resource.c */ -struct ldlm_namespace *ldlm_namespace_find(__u32 id); -ldlm_error_t ldlm_namespace_new(struct obd_device *, __u32 id, - struct ldlm_namespace **); +struct ldlm_namespace *ldlm_namespace_new(char *name, __u32 local); +int ldlm_namespace_cleanup(struct ldlm_namespace *ns, int local_only); int ldlm_namespace_free(struct ldlm_namespace *ns); +int ldlm_proc_setup(struct obd_device *obd); +void ldlm_proc_cleanup(struct obd_device *obd); + +/* resource.c - internal */ struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent, __u64 *name, __u32 type, int create); +struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res); int ldlm_resource_put(struct ldlm_resource *res); void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, struct ldlm_lock *lock); -void ldlm_resource_del_lock(struct ldlm_lock *lock); +void ldlm_resource_unlink_lock(struct ldlm_lock *lock); void ldlm_res2desc(struct ldlm_resource *res, struct ldlm_resource_desc *desc); -void ldlm_resource_dump(struct ldlm_resource *res); +void ldlm_dump_all_namespaces(void); +void ldlm_namespace_dump(struct ldlm_namespace *); +void ldlm_resource_dump(struct ldlm_resource *); +int ldlm_lock_change_resource(struct ldlm_lock *, __u64 new_resid[3]); /* ldlm_request.c */ -int ldlm_cli_namespace_new(struct obd_device *, struct ptlrpc_client *, - struct ptlrpc_connection *, __u32 ns_id); -int ldlm_cli_enqueue(struct ptlrpc_client *cl, struct ptlrpc_connection *peer, - __u32 ns_id, - struct ldlm_handle *parent_lock_handle, +int ldlm_completion_ast(struct ldlm_lock *lock, int flags); +int ldlm_cli_enqueue(struct lustre_handle *conn, + struct ptlrpc_request *req, + struct ldlm_namespace *ns, + struct lustre_handle *parent_lock_handle, __u64 *res_id, __u32 type, - struct ldlm_extent *req_ex, + void *cookie, int cookielen, ldlm_mode_t mode, int *flags, - ldlm_lock_callback completion, - ldlm_lock_callback blocking, + ldlm_completion_callback completion, + ldlm_blocking_callback callback, void *data, __u32 data_len, - struct ldlm_handle *lockh, - struct ptlrpc_request **request); -int ldlm_cli_callback(struct ldlm_lock *lock, struct ldlm_lock *new, - void *data, __u32 data_len); -int ldlm_cli_convert(struct ptlrpc_client *, struct ldlm_handle *, - int new_mode, int *flags, struct ptlrpc_request **); -int ldlm_cli_cancel(struct ptlrpc_client *, struct ldlm_handle *, - struct ptlrpc_request **); - + struct lustre_handle *lockh); +int ldlm_match_or_enqueue(struct lustre_handle *connh, + struct ptlrpc_request *req, + struct ldlm_namespace *ns, + struct lustre_handle *parent_lock_handle, + __u64 *res_id, + __u32 type, + void *cookie, int cookielen, + ldlm_mode_t mode, + int *flags, + ldlm_completion_callback completion, + ldlm_blocking_callback callback, + void *data, + __u32 data_len, + struct lustre_handle *lockh); +int ldlm_server_ast(struct lustre_handle *lockh, struct ldlm_lock_desc *new, + void *data, __u32 data_len); +int ldlm_cli_convert(struct lustre_handle *, int new_mode, int *flags); +int ldlm_cli_cancel(struct lustre_handle *lockh); +int ldlm_cli_cancel_unused(struct ldlm_namespace *, __u64 *, int local_only); + +/* mds/handler.c */ +/* This has to be here because recurisve inclusion sucks. */ +int mds_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, + void *data, __u32 data_len, int flag); #endif /* __KERNEL__ */ @@ -261,6 +413,9 @@ int ldlm_cli_cancel(struct ptlrpc_client *, struct ldlm_handle *, #define IOC_LDLM_MIN_NR 40 #define IOC_LDLM_TEST _IOWR('f', 40, long) -#define IOC_LDLM_MAX_NR 41 +#define IOC_LDLM_DUMP _IOWR('f', 41, long) +#define IOC_LDLM_REGRESS_START _IOWR('f', 42, long) +#define IOC_LDLM_REGRESS_STOP _IOWR('f', 43, long) +#define IOC_LDLM_MAX_NR 43 #endif