X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flinux%2Flustre_dlm.h;h=4324ee28f76746f9c26bb389ca62dd8b62a64524;hb=69b292d708e6d12e0849ee1293dded75a6e54d0b;hp=3451a669cb5844ffd882118ad17e61ece66a7d3a;hpb=616e61d0c24f2316b2cc832818d3410a68a2eb24;p=fs%2Flustre-release.git diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h index 3451a66..4324ee2 100644 --- a/lustre/include/linux/lustre_dlm.h +++ b/lustre/include/linux/lustre_dlm.h @@ -7,8 +7,13 @@ #ifdef __KERNEL__ -#include +#include +#include #include +#include + +struct obd_ops; +struct obd_device; #define OBD_LDLM_DEVICENAME "ldlm" @@ -17,7 +22,6 @@ typedef enum { ELDLM_LOCK_CHANGED = 300, ELDLM_LOCK_ABORTED = 301, - ELDLM_RESOURCE_FREED = 302, ELDLM_NAMESPACE_EXISTS = 400, ELDLM_BAD_NAMESPACE = 401 @@ -33,6 +37,11 @@ typedef enum { #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) @@ -63,34 +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 { - char *ns_name; - struct ptlrpc_client ns_rpc_client; /* used for revocation callbacks */ - __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 lustre_lock ns_lock; /* protects hash, refcount, list */ + 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 * */ @@ -100,30 +113,34 @@ struct ldlm_namespace { struct ldlm_lock; -typedef int (*ldlm_lock_callback)(struct lustre_handle *lockh, - struct ldlm_lock_desc *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; + __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*/ - atomic_t l_refcount; + 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; + ldlm_completion_callback l_completion_ast; + ldlm_blocking_callback l_blocking_ast; - struct ptlrpc_connection *l_connection; - struct ptlrpc_client *l_client; + struct obd_export *l_export; + struct lustre_handle *l_connh; __u32 l_flags; - struct lustre_handle l_remote_handle; + struct lustre_handle l_remote_handle; void *l_data; __u32 l_data_len; void *l_cookie; @@ -151,16 +168,16 @@ typedef int (*ldlm_res_policy)(struct ldlm_lock *lock, void *req_cookie, #define LDLM_MIN_TYPE 10 #define LDLM_MAX_TYPE 12 -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; @@ -174,15 +191,22 @@ struct ldlm_resource { void *lr_tmp; }; -struct ldlm_ast_work { +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) { return (struct ldlm_extent *)(res->lr_name); @@ -190,35 +214,98 @@ static inline struct ldlm_extent *ldlm_res2extent(struct ldlm_resource *res) extern struct obd_ops ldlm_obd_ops; - extern char *ldlm_lockname[]; extern char *ldlm_typename[]; - -#define LDLM_DEBUG(lock, format, a...) \ -do { \ - CDEBUG(D_DLMTRACE, "### " format \ - " (%s: lock %p mode %s/%s on res %Lu (rc %d) " \ - " type %s remote %Lx)\n" , ## a, \ - lock->l_resource->lr_namespace->ns_name, lock, \ - 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); \ +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; + /* 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 *); +/* 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); + /* 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 *handle); +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) +{ + return __ldlm_handle2lock(h, 1); +} + +#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); @@ -236,20 +323,32 @@ ldlm_lock_create(struct ldlm_namespace *ns, __u32 data_len); ldlm_error_t ldlm_lock_enqueue(struct ldlm_lock *lock, void *cookie, int cookie_len, int *flags, - ldlm_lock_callback completion, - ldlm_lock_callback blocking); -struct ldlm_resource *ldlm_convert(struct ldlm_lock *lock, int new_mode, + 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_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, @@ -261,12 +360,14 @@ void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, 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); -int ldlm_lock_change_resource(struct ldlm_lock *lock, __u64 new_resid[3]); +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_enqueue(struct ptlrpc_client *cl, - struct ptlrpc_connection *peer, +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, @@ -275,15 +376,35 @@ int ldlm_cli_enqueue(struct ptlrpc_client *cl, void *cookie, int cookielen, ldlm_mode_t mode, int *flags, - ldlm_lock_callback callback, + ldlm_completion_callback completion, + ldlm_blocking_callback callback, void *data, __u32 data_len, 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 ptlrpc_client *, struct lustre_handle *, - int new_mode, int *flags); -int ldlm_cli_cancel(struct lustre_handle *); +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__ */ @@ -292,6 +413,9 @@ int ldlm_cli_cancel(struct lustre_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