fs: dlm: misc cleanups
Subsystems (5)
Alexander Aring
maintainercover fs: dlm: misc cleanups
Hi,
as I am working on some bigger change in the callback handling I separated this patch series from a bigger series. This series removes unused prototype, change a lock to spinlock because no sleepable context, adding traces for user space locks, moving DLM_LSFL_FS out of uapi because the user space should never set this flag and move LSFL_CB_DELAY to kernel space lockspaces only.
- Alex
Alexander Aring (5):
fs: dlm: remove dlm_del_ast prototype
fs: dlm: change ls_clear_proc_locks to spinlock
fs: dlm: trace user space callbacks
fs: dlm: move DLM_LSFL_FS out of uapi
fs: dlm: LSFL_CB_DELAY only for kernel lockspaces
drivers/md/md-cluster.c | 4 ++-- fs/dlm/ast.c | 13 +++++++------ fs/dlm/ast.h | 1 - fs/dlm/dlm_internal.h | 2 +- fs/dlm/lock.c | 32 ++++++++++++++++++++++++-------- fs/dlm/lockspace.c | 30 +++++++++++++++++++++++++----- fs/dlm/lockspace.h | 13 +++++++++++++ fs/dlm/user.c | 17 +++++++++++------ fs/gfs2/lock_dlm.c | 2 +- fs/ocfs2/stack_user.c | 2 +- include/linux/dlm.h | 3 --- include/trace/events/dlm.h | 23 +++++++++++++---------- include/uapi/linux/dlm.h | 1 - 13 files changed, 98 insertions(+), 45 deletions(-)
Signature · 1 line
2.31.1
Alexander Aring
maintainerPATCH 1/5 fs: dlm: remove dlm_del_ast prototype
This patch removes dlm_del_ast() prototype which is not being used in the dlm subsystem because there is not implementation for it.
--- fs/dlm/ast.h | 1 - 1 file changed, 1 deletion(-)
fs/dlm/ast.h +0 -1
@@ -11,7 +11,6 @@#ifndef __ASTD_DOT_H__#define __ASTD_DOT_H__ -void dlm_del_ast (struct dlm_lkb *lkb);int dlm_add_lkb_callback (struct dlm_lkb *lkb,uint32_t flags,int mode,int status,uint32_t sbflags,uint64_t seq); int dlm_rem_lkb_callback(struct dlm_ls *ls, struct dlm_lkb *lkb,
Signature · 1 line
2.31.1
Alexander Aring
maintainerPATCH 2/5 fs: dlm: change ls_clear_proc_locks to spinlock
In reply to Alexander AringThis patch changes the ls_clear_proc_locks to a spinlock because there is no need to handle it as a mutex as there is no sleepable context when ls_clear_proc_locks is held. This allows us to call those functionality in non-sleepable contexts.
--- fs/dlm/dlm_internal.h | 2 +- fs/dlm/lock.c | 8 ++++---- fs/dlm/lockspace.c | 2 +- fs/dlm/user.c | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-)
fs/dlm/dlm_internal.h +1 -1
@@ -661,7 +661,7 @@ struct dlm_ls {spinlock_t ls_recover_idr_lock;wait_queue_head_t ls_wait_general;wait_queue_head_t ls_recover_lock_wait; -struct mutex ls_clear_proc_locks; +spinlock_t ls_clear_proc_locks;struct list_head ls_root_list;/* root resources */ struct rw_semaphore ls_root_sem;/* protect root_list */
fs/dlm/lock.c +4 -4
@@ -6208,7 +6208,7 @@ static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls, {struct dlm_lkb *lkb =NULL ; -mutex_lock (&ls->ls_clear_proc_locks); +spin_lock (&ls->ls_clear_proc_locks);if (list_empty (&proc->locks)) goto out;
@@ -6220,7 +6220,7 @@ static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls,else lkb->lkb_flags |=DLM_IFL_DEAD ; out: -mutex_unlock (&ls->ls_clear_proc_locks); +spin_unlock (&ls->ls_clear_proc_locks);return lkb; }
@@ -6257,7 +6257,7 @@ void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)dlm_put_lkb (lkb); } -mutex_lock (&ls->ls_clear_proc_locks); +spin_lock (&ls->ls_clear_proc_locks);/* in-progress unlocks */ list_for_each_entry_safe (lkb, safe, &proc->unlocking, lkb_ownqueue) {
@@ -6273,7 +6273,7 @@ void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)dlm_put_lkb (lkb); } -mutex_unlock (&ls->ls_clear_proc_locks); +spin_unlock (&ls->ls_clear_proc_locks);dlm_unlock_recovery (ls); }
fs/dlm/lockspace.c +1 -1
@@ -584,7 +584,7 @@ static int new_lockspace(const char *name, const char *cluster,atomic_set (&ls->ls_requestqueue_cnt,0 );init_waitqueue_head (&ls->ls_requestqueue_wait);mutex_init (&ls->ls_requestqueue_mutex); -mutex_init (&ls->ls_clear_proc_locks); +spin_lock_init (&ls->ls_clear_proc_locks);/* Due backwards compatibility with 3.1 we need to use maximum * possible dlm message size to be sure the message will fit and
fs/dlm/user.c +2 -2
@@ -184,7 +184,7 @@ void dlm_user_add_ast(struct dlm_lkb *lkb, uint32_t flags, int mode,return ; ls = lkb->lkb_resource->res_ls; -mutex_lock (&ls->ls_clear_proc_locks); +spin_lock (&ls->ls_clear_proc_locks);/* If ORPHAN/DEAD flag is set, it means the process is dead so an ast can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed
@@ -230,7 +230,7 @@ void dlm_user_add_ast(struct dlm_lkb *lkb, uint32_t flags, int mode,spin_unlock (&proc->locks_spin); } out: -mutex_unlock (&ls->ls_clear_proc_locks); +spin_unlock (&ls->ls_clear_proc_locks); } static int device_user_lock(struct dlm_user_proc *proc,
Signature · 1 line
2.31.1
Alexander Aring
maintainerPATCH 3/5 fs: dlm: trace user space callbacks
In reply to Alexander AringThis patch adds trace callbacks for user locks. Unfortenately user locks are handled in a different way than kernel locks in some cases. User locks never call the dlm_lock()/dlm_unlock() kernel API and use the next step internal API of dlm. Adding those traces from user API callers should make it possible for dlm trace system to see lock handling for user locks as well.
--- fs/dlm/lock.c | 24 ++++++++++++++++++++---- fs/dlm/user.c | 7 ++++++- include/trace/events/dlm.h | 23 +++++++++++++---------- 3 files changed, 39 insertions(+), 15 deletions(-)
fs/dlm/lock.c +20 -4
@@ -3462,7 +3462,7 @@ int dlm_lock(dlm_lockspace_t *lockspace,if (error == -EINPROGRESS ) error =0 ; out_put: -trace_dlm_lock_end (ls, lkb, name, namelen, mode, flags, error); +trace_dlm_lock_end (ls, lkb, name, namelen, mode, flags, error, true);if (convert || error)__put_lkb (ls, lkb);
@@ -5835,13 +5835,15 @@ int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua, goto out; } +trace_dlm_lock_start (ls, lkb, name, namelen, mode, flags); +if (flags &DLM_LKF_VALBLK ) { ua->lksb.sb_lvbptr =kzalloc (DLM_USER_LVB_LEN ,GFP_NOFS );if (!ua->lksb.sb_lvbptr) {kfree (ua);__put_lkb (ls, lkb); error = -ENOMEM ; - goto out; + goto out_trace_end; } }#ifdef CONFIG_DLM_DEPRECATED_API
@@ -5856,7 +5858,7 @@ int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua, ua->lksb.sb_lvbptr =NULL ;kfree (ua);__put_lkb (ls, lkb); - goto out; + goto out_trace_end; }/* After ua is attached to lkb it will be freed by dlm_free_lkb().
@@ -5876,7 +5878,7 @@ int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua, fallthrough;default :__put_lkb (ls, lkb); - goto out; + goto out_trace_end; }/* add this new lkb to the per-process list of locks */
@@ -5884,6 +5886,8 @@ int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,hold_lkb (lkb);list_add_tail (&lkb->lkb_ownqueue, &ua->proc->locks);spin_unlock (&ua->proc->locks_spin); + out_trace_end: +trace_dlm_lock_end (ls, lkb, name, namelen, mode, flags, error, false); out:dlm_unlock_recovery (ls);return error;
@@ -5909,6 +5913,8 @@ int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,if (error) goto out; +trace_dlm_lock_start (ls, lkb,NULL ,0 , mode, flags); +/* user can change the params on its lock when it converts it, or add an lvb that didn't exist before */
@@ -5946,6 +5952,7 @@ int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,if (error == -EINPROGRESS || error == -EAGAIN || error == -EDEADLK ) error =0 ; out_put: +trace_dlm_lock_end (ls, lkb,NULL ,0 , mode, flags, error, false);dlm_put_lkb (lkb); out:dlm_unlock_recovery (ls);
@@ -6038,6 +6045,8 @@ int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,if (error) goto out; +trace_dlm_unlock_start (ls, lkb, flags); + ua = lkb->lkb_ua;if (lvb_in && ua->lksb.sb_lvbptr)
@@ -6066,6 +6075,7 @@ int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,list_move (&lkb->lkb_ownqueue, &ua->proc->unlocking);spin_unlock (&ua->proc->locks_spin); out_put: +trace_dlm_unlock_end (ls, lkb, flags, error);dlm_put_lkb (lkb); out:dlm_unlock_recovery (ls);
@@ -6087,6 +6097,8 @@ int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,if (error) goto out; +trace_dlm_unlock_start (ls, lkb, flags); + ua = lkb->lkb_ua;if (ua_tmp->castparam) ua->castparam = ua_tmp->castparam;
@@ -6104,6 +6116,7 @@ int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,if (error == -EBUSY ) error =0 ; out_put: +trace_dlm_unlock_end (ls, lkb, flags, error);dlm_put_lkb (lkb); out:dlm_unlock_recovery (ls);
@@ -6125,6 +6138,8 @@ int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)if (error) goto out; +trace_dlm_unlock_start (ls, lkb, flags); + ua = lkb->lkb_ua; error =set_unlock_args (flags, ua, &args);
@@ -6153,6 +6168,7 @@ int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)if (error == -EBUSY ) error =0 ; out_put: +trace_dlm_unlock_end (ls, lkb, flags, error);dlm_put_lkb (lkb); out:dlm_unlock_recovery (ls);
fs/dlm/user.c +6 -1
@@ -16,6 +16,8 @@#include <linux/slab.h> #include <linux/sched/signal.h> +#include <trace/events/dlm.h> +#include "dlm_internal.h" #include "lockspace.h" #include "lock.h"
@@ -882,7 +884,9 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count, goto try_another; } -if (cb.flags &DLM_CB_CAST ) { +if (cb.flags &DLM_CB_BAST ) { +trace_dlm_bast (lkb->lkb_resource->res_ls, lkb, cb.mode); + }else if (cb.flags &DLM_CB_CAST ) { new_mode = cb.mode; if (!cb.sb_status && lkb->lkb_lksb->sb_lvbptr &&
@@ -891,6 +895,7 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count, lkb->lkb_lksb->sb_status = cb.sb_status; lkb->lkb_lksb->sb_flags = cb.sb_flags; +trace_dlm_ast (lkb->lkb_resource->res_ls, lkb); } rv = copy_result_to_user(lkb->lkb_ua,
include/trace/events/dlm.h +13 -10
@@ -92,9 +92,10 @@ TRACE_EVENT(dlm_lock_start, TRACE_EVENT(dlm_lock_end, TP_PROTO(struct dlm_ls *ls, struct dlm_lkb *lkb, void *name, - unsigned int namelen, int mode, __u32 flags, int error), + unsigned int namelen, int mode, __u32 flags, int error, + bool kernel_lock), - TP_ARGS(ls, lkb, name, namelen, mode, flags, error), + TP_ARGS(ls, lkb, name, namelen, mode, flags, error, kernel_lock), TP_STRUCT__entry( __field(__u32, ls_id)
@@ -122,14 +123,16 @@ TRACE_EVENT(dlm_lock_end,memcpy (__get_dynamic_array (res_name), name,__get_dynamic_array_len (res_name)); -/* return value will be zeroed in those cases by dlm_lock() -* we do it here again to not introduce more overhead if -* trace isn't running and error reflects the return value. -*/ -if (error == -EAGAIN || error == -EDEADLK ) - __entry->error =0 ; -else - __entry->error = error; +if (kernel_lock) { +/* return value will be zeroed in those cases by dlm_lock() +* we do it here again to not introduce more overhead if +* trace isn't running and error reflects the return value. +*/ +if (error == -EAGAIN || error == -EDEADLK ) + __entry->error =0 ; +else + __entry->error = error; + } ),
Signature · 1 line
2.31.1
Alexander Aring
maintainerPATCH 3/5 fs: dlm: trace user space callbacks
Hi,
On Mon, Jul 25, 2022 at 4:38 PM Alexander Aring <[email protected]> wrote:
...
Quoted 26 lines
include/trace/events/dlm.h +3
-9@@ -92,9 +92,10 @@ TRACE_EVENT(dlm_lock_start, TRACE_EVENT(dlm_lock_end, TP_PROTO(struct dlm_ls *ls, struct dlm_lkb *lkb, void *name, - unsigned int namelen, int mode, __u32 flags, int error), + unsigned int namelen, int mode, __u32 flags, int error, + bool kernel_lock), - TP_ARGS(ls, lkb, name, namelen, mode, flags, error), + TP_ARGS(ls, lkb, name, namelen, mode, flags, error, kernel_lock), TP_STRUCT__entry( __field(__u32, ls_id)@@ -122,14 +123,16 @@ TRACE_EVENT(dlm_lock_end,memcpy (__get_dynamic_array (res_name), name,__get_dynamic_array_len (res_name)); -/* return value will be zeroed in those cases by dlm_lock() -* we do it here again to not introduce more overhead if -* trace isn't running and error reflects the return value. -*/ -if (error == -EAGAIN || error == -EDEADLK ) - __entry->error =0 ; -else
include/trace/events/dlm.h TRACE_EVENT(dlm_lock_end, · line 134
Quoted 10 lines
include/trace/events/dlm.h +9
-1- __entry->error = error; +if (kernel_lock) { +/* return value will be zeroed in those cases by dlm_lock() +* we do it here again to not introduce more overhead if +* trace isn't running and error reflects the return value. +*/ +if (error == -EAGAIN || error == -EDEADLK ) + __entry->error =0 ; +else + __entry->error = error;
I need to investigate why my user space block calls drop all weird error numbers... We need to assign this value for user space locks as well. I will remove the else branch and move the handling above to all other field assignments and if it's kernel lock there is a special handling which is different on kernel locks only... this handling is still required.
- Alex
Alexander Aring
maintainerPATCH 4/5 fs: dlm: move DLM_LSFL_FS out of uapi
In reply to Alexander AringThe DLM_LSFL_FS should be never part of the dlm lockspace uapi headers. If a user space dlm user is using this flag it's doing something wrong for user space flags. If their program doesn't compile anymore because this flag is missing we do a favour for them by signaling them there is a bug. Even the kernel lockspaces does not need to set this flag. This patch will always set it for kernel space lockspaces and do not set it for user space lockspaces so no mistake can happen anymore. In future we hopefully can silently remove this flag and this bit can be get reused for something else.
--- drivers/md/md-cluster.c | 4 ++-- fs/dlm/lockspace.c | 28 ++++++++++++++++++++++++---- fs/dlm/lockspace.h | 13 +++++++++++++ fs/dlm/user.c | 6 +++--- fs/gfs2/lock_dlm.c | 2 +- fs/ocfs2/stack_user.c | 2 +- include/linux/dlm.h | 3 --- include/uapi/linux/dlm.h | 1 - 8 files changed, 44 insertions(+), 15 deletions(-)
drivers/md/md-cluster.c +2 -2
@@ -876,8 +876,8 @@ static int join(struct mddev *mddev, int nodes)memset (str,0 ,64 );sprintf (str,"%pU" , mddev->uuid); ret =dlm_new_lockspace (str, mddev->bitmap_info.cluster_name, -DLM_LSFL_FS ,LVB_SIZE , - &md_ls_ops, mddev, &ops_rv, &cinfo->lockspace); +0 ,LVB_SIZE , &md_ls_ops, mddev, + &ops_rv, &cinfo->lockspace);if (ret) goto err;wait_for_completion (&cinfo->completion);
fs/dlm/lockspace.c +24 -4
@@ -703,10 +703,11 @@ static int new_lockspace(const char *name, const char *cluster,return error; } -int dlm_new_lockspace (const char *name,const char *cluster, -uint32_t flags,int lvblen, -const struct dlm_lockspace_ops *ops,void *ops_arg, -int *ops_result,dlm_lockspace_t **lockspace) +static int __dlm_new_lockspace (const char *name,const char *cluster, +uint32_t flags,int lvblen, +const struct dlm_lockspace_ops *ops, +void *ops_arg,int *ops_result, +dlm_lockspace_t **lockspace) {int error =0 ;
@@ -732,6 +733,25 @@ int dlm_new_lockspace(const char *name, const char *cluster,return error; } +int dlm_new_lockspace (const char *name,const char *cluster,uint32_t flags, +int lvblen,const struct dlm_lockspace_ops *ops, +void *ops_arg,int *ops_result, +dlm_lockspace_t **lockspace) +{ +return __dlm_new_lockspace (name, cluster, flags |DLM_LSFL_FS , lvblen, + ops, ops_arg, ops_result, lockspace); +} + +int dlm_new_user_lockspace (const char *name,const char *cluster, +uint32_t flags,int lvblen, +const struct dlm_lockspace_ops *ops, +void *ops_arg,int *ops_result, +dlm_lockspace_t **lockspace) +{ +return __dlm_new_lockspace (name, cluster, flags, lvblen, ops, + ops_arg, ops_result, lockspace); +} +static int lkb_idr_is_local (int id,void *p,void *data) {struct dlm_lkb *lkb = p;
fs/dlm/lockspace.h +13 -0
@@ -12,6 +12,14 @@#ifndef __LOCKSPACE_DOT_H__#define __LOCKSPACE_DOT_H__ +/* DLM_LSFL_FS +* The lockspace user is in the kernel (i.e. filesystem). Enables +* direct bast/cast callbacks. +* +* internal lockspace flag - will be removed in future +*/ +#define DLM_LSFL_FS 0x00000004 +int dlm_lockspace_init (void );void dlm_lockspace_exit (void );struct dlm_ls *dlm_find_lockspace_global (uint32_t id);
@@ -20,6 +28,11 @@ struct dlm_ls *dlm_find_lockspace_device(int minor);void dlm_put_lockspace (struct dlm_ls *ls);void dlm_stop_lockspaces (void );void dlm_stop_lockspaces_check (void ); +int dlm_new_user_lockspace (const char *name,const char *cluster, +uint32_t flags,int lvblen, +const struct dlm_lockspace_ops *ops, +void *ops_arg,int *ops_result, +dlm_lockspace_t **lockspace);#endif /* __LOCKSPACE_DOT_H__ */
fs/dlm/user.c +3 -3
@@ -423,9 +423,9 @@ static int device_create_lockspace(struct dlm_lspace_params *params)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; - error =dlm_new_lockspace (params->name, dlm_config.ci_cluster_name, params->flags, -DLM_USER_LVB_LEN ,NULL ,NULL ,NULL , - &lockspace); + error =dlm_new_user_lockspace (params->name, dlm_config.ci_cluster_name, + params->flags,DLM_USER_LVB_LEN ,NULL , +NULL ,NULL , &lockspace);if (error)return error;
fs/gfs2/lock_dlm.c +1 -1
@@ -1302,7 +1302,7 @@ static int gdlm_mount(struct gfs2_sbd *sdp, const char *table)memcpy (cluster, table,strlen (table) -strlen (fsname)); fsname++; - flags =DLM_LSFL_FS |DLM_LSFL_NEWEXCL ; + flags =DLM_LSFL_NEWEXCL ;/* * create/join lockspace
fs/ocfs2/stack_user.c +1 -1
@@ -991,7 +991,7 @@ static int user_cluster_connect(struct ocfs2_cluster_connection *conn) lc->oc_type =NO_CONTROLD ; rc =dlm_new_lockspace (conn->cc_name, conn->cc_cluster_name, -DLM_LSFL_FS |DLM_LSFL_NEWEXCL ,DLM_LVB_LEN , +DLM_LSFL_NEWEXCL ,DLM_LVB_LEN , &ocfs2_ls_ops, conn, &ops_rv, &fsdlm);if (rc) {if (rc == -EEXIST || rc == -EPROTO )
include/linux/dlm.h +0 -3
@@ -56,9 +56,6 @@ struct dlm_lockspace_ops {* DLM_LSFL_TIMEWARN * The dlm should emit netlink messages if locks have been waiting * for a configurable amount of time. (Unused.) -* DLM_LSFL_FS -* The lockspace user is in the kernel (i.e. filesystem). Enables -* direct bast/cast callbacks. * DLM_LSFL_NEWEXCL * dlm_new_lockspace() should return -EEXIST if the lockspace exists. *
include/uapi/linux/dlm.h +0 -1
@@ -69,7 +69,6 @@ struct dlm_lksb {/* dlm_new_lockspace() flags */ #define DLM_LSFL_TIMEWARN 0x00000002 -#define DLM_LSFL_FS 0x00000004#define DLM_LSFL_NEWEXCL 0x00000008
Signature · 1 line
2.31.1
Alexander Aring
maintainerPATCH 5/5 fs: dlm: LSFL_CB_DELAY only for kernel lockspaces
In reply to Alexander AringThis patch only set/clear the LSFL_CB_DELAY bit when it's actually a kernel lockspace signaled by if ls->ls_callback_wq is set or not set in this case. User lockspaces will never evaluate this flag.
--- fs/dlm/ast.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
fs/dlm/ast.c +7 -6
@@ -288,12 +288,13 @@ void dlm_callback_stop(struct dlm_ls *ls)void dlm_callback_suspend (struct dlm_ls *ls) { -mutex_lock (&ls->ls_cb_mutex); -set_bit (LSFL_CB_DELAY , &ls->ls_flags); -mutex_unlock (&ls->ls_cb_mutex); +if (ls->ls_callback_wq) { +mutex_lock (&ls->ls_cb_mutex); +set_bit (LSFL_CB_DELAY , &ls->ls_flags); +mutex_unlock (&ls->ls_cb_mutex); -if (ls->ls_callback_wq)flush_workqueue (ls->ls_callback_wq); + } }#define MAX_CB_QUEUE 25
@@ -304,11 +305,11 @@ void dlm_callback_resume(struct dlm_ls *ls)int count =0 , sum =0 ;bool empty; -clear_bit (LSFL_CB_DELAY , &ls->ls_flags); -if (!ls->ls_callback_wq)return ; +clear_bit (LSFL_CB_DELAY , &ls->ls_flags); + more:mutex_lock (&ls->ls_cb_mutex);list_for_each_entry_safe (lkb, safe, &ls->ls_cb_delay, lkb_cb_list) {
Signature · 1 line
2.31.1