Commit f097ef0e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'dlm-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/linux-dlm 

Pull dlm updates from David Teigland:

 - New flag DLM_LSFL_SOFTIRQ_SAFE can be set by code using dlm to
   indicate callbacks can be run from softirq

 - Change md-cluster to set DLM_LSFL_SOFTIRQ_SAFE

 - Clean up for previous changes, e.g. unused code and parameters

 - Remove custom pre-allocation of rsb structs which is unnecessary with
   kmem caches

 - Change idr to xarray for lkb structs in use

 - Change idr to xarray for rsb structs being recovered

 - Change outdated naming related to internal rsb states

 - Fix some incorrect add/remove of rsb on scan list

 - Use rcu to free rsb structs

* tag 'dlm-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/linux-dlm:
  dlm: add rcu_barrier before destroy kmem cache
  dlm: remove DLM_LSFL_SOFTIRQ from exflags
  fs: dlm: remove unused struct 'dlm_processed_nodes'
  md-cluster: use DLM_LSFL_SOFTIRQ for dlm_new_lockspace()
  dlm: implement LSFL_SOFTIRQ_SAFE
  dlm: introduce DLM_LSFL_SOFTIRQ_SAFE
  dlm: use LSFL_FS to check for kernel lockspace
  dlm: use rcu to avoid an extra rsb struct lookup
  dlm: fix add_scan and del_scan usage
  dlm: change list and timer names
  dlm: move recover idr to xarray datastructure
  dlm: move lkb idr to xarray datastructure
  dlm: drop own rsb pre allocation mechanism
  dlm: remove ls_local_handle from struct dlm_ls
  dlm: remove unused parameter in dlm_midcomms_addr
  dlm: don't kref_init rsbs created for toss list
  dlm: remove scand leftovers
parents 586f14a6 89b01913

drivers/md/md-cluster.c

+1 −1
Original line number Diff line number Diff line
@@ -887,7 +887,7 @@ 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,

				0, LVB_SIZE, &md_ls_ops, mddev,

				DLM_LSFL_SOFTIRQ, LVB_SIZE, &md_ls_ops, mddev,

				&ops_rv, &cinfo->lockspace);

	if (ret)

		goto err;

fs/dlm/ast.c

+111 −61
Original line number Diff line number Diff line
@@ -18,35 +18,52 @@ 
#include "user.h"

#include "ast.h"



static void dlm_callback_work(struct work_struct *work)

static void dlm_run_callback(uint32_t ls_id, uint32_t lkb_id, int8_t mode,

			     uint32_t flags, uint8_t sb_flags, int sb_status,

			     struct dlm_lksb *lksb,

			     void (*astfn)(void *astparam),

			     void (*bastfn)(void *astparam, int mode),

			     void *astparam, const char *res_name,

			     size_t res_length)

{

	struct dlm_callback *cb = container_of(work, struct dlm_callback, work);



	if (cb->flags & DLM_CB_BAST) {

		trace_dlm_bast(cb->ls_id, cb->lkb_id, cb->mode, cb->res_name,

			       cb->res_length);

		cb->bastfn(cb->astparam, cb->mode);

	} else if (cb->flags & DLM_CB_CAST) {

		trace_dlm_ast(cb->ls_id, cb->lkb_id, cb->sb_status,

			      cb->sb_flags, cb->res_name, cb->res_length);

		cb->lkb_lksb->sb_status = cb->sb_status;

		cb->lkb_lksb->sb_flags = cb->sb_flags;

		cb->astfn(cb->astparam);

	if (flags & DLM_CB_BAST) {

		trace_dlm_bast(ls_id, lkb_id, mode, res_name, res_length);

		bastfn(astparam, mode);

	} else if (flags & DLM_CB_CAST) {

		trace_dlm_ast(ls_id, lkb_id, sb_status, sb_flags, res_name,

			      res_length);

		lksb->sb_status = sb_status;

		lksb->sb_flags = sb_flags;

		astfn(astparam);

	}

}



static void dlm_do_callback(struct dlm_callback *cb)

{

	dlm_run_callback(cb->ls_id, cb->lkb_id, cb->mode, cb->flags,

			 cb->sb_flags, cb->sb_status, cb->lkb_lksb,

			 cb->astfn, cb->bastfn, cb->astparam,

			 cb->res_name, cb->res_length);

	dlm_free_cb(cb);

}



int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode,

			   int status, uint32_t sbflags,

			   struct dlm_callback **cb)

static void dlm_callback_work(struct work_struct *work)

{

	struct dlm_callback *cb = container_of(work, struct dlm_callback, work);



	dlm_do_callback(cb);

}



bool dlm_may_skip_callback(struct dlm_lkb *lkb, uint32_t flags, int mode,

			   int status, uint32_t sbflags, int *copy_lvb)

{

	struct dlm_rsb *rsb = lkb->lkb_resource;

	int rv = DLM_ENQUEUE_CALLBACK_SUCCESS;

	struct dlm_ls *ls = rsb->res_ls;

	int copy_lvb = 0;

	int prev_mode;



	if (copy_lvb)

		*copy_lvb = 0;



	if (flags & DLM_CB_BAST) {

		/* if cb is a bast, it should be skipped if the blocking mode is

		 * compatible with the last granted mode
@@ -56,7 +73,7 @@ int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode, 
				log_debug(ls, "skip %x bast mode %d for cast mode %d",

					  lkb->lkb_id, mode,

					  lkb->lkb_last_cast_cb_mode);

				goto out;

				return true;

			}

		}
@@ -74,7 +91,7 @@ int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode, 
			    (prev_mode > mode && prev_mode > DLM_LOCK_PR)) {

				log_debug(ls, "skip %x add bast mode %d for bast mode %d",

					  lkb->lkb_id, mode, prev_mode);

				goto out;

				return true;

			}

		}
@@ -85,8 +102,10 @@ int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode, 
			prev_mode = lkb->lkb_last_cast_cb_mode;



			if (!status && lkb->lkb_lksb->sb_lvbptr &&

			    dlm_lvb_operations[prev_mode + 1][mode + 1])

				copy_lvb = 1;

			    dlm_lvb_operations[prev_mode + 1][mode + 1]) {

				if (copy_lvb)

					*copy_lvb = 1;

			}

		}



		lkb->lkb_last_cast_cb_mode = mode;
@@ -96,12 +115,20 @@ int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode, 
	lkb->lkb_last_cb_mode = mode;

	lkb->lkb_last_cb_flags = flags;



	*cb = dlm_allocate_cb();

	if (!*cb) {

		rv = DLM_ENQUEUE_CALLBACK_FAILURE;

		goto out;

	return false;

}



int dlm_get_cb(struct dlm_lkb *lkb, uint32_t flags, int mode,

	       int status, uint32_t sbflags,

	       struct dlm_callback **cb)

{

	struct dlm_rsb *rsb = lkb->lkb_resource;

	struct dlm_ls *ls = rsb->res_ls;



	*cb = dlm_allocate_cb();

	if (WARN_ON_ONCE(!*cb))

		return -ENOMEM;



	/* for tracing */

	(*cb)->lkb_id = lkb->lkb_id;

	(*cb)->ls_id = ls->ls_global_id;
@@ -112,19 +139,34 @@ int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode, 
	(*cb)->mode = mode;

	(*cb)->sb_status = status;

	(*cb)->sb_flags = (sbflags & 0x000000FF);

	(*cb)->copy_lvb = copy_lvb;

	(*cb)->lkb_lksb = lkb->lkb_lksb;



	rv = DLM_ENQUEUE_CALLBACK_NEED_SCHED;

	return 0;

}



out:

static int dlm_get_queue_cb(struct dlm_lkb *lkb, uint32_t flags, int mode,

			    int status, uint32_t sbflags,

			    struct dlm_callback **cb)

{

	int rv;



	rv = dlm_get_cb(lkb, flags, mode, status, sbflags, cb);

	if (rv)

		return rv;



	(*cb)->astfn = lkb->lkb_astfn;

	(*cb)->bastfn = lkb->lkb_bastfn;

	(*cb)->astparam = lkb->lkb_astparam;

	INIT_WORK(&(*cb)->work, dlm_callback_work);



	return 0;

}



void dlm_add_cb(struct dlm_lkb *lkb, uint32_t flags, int mode, int status,

		uint32_t sbflags)

{

	struct dlm_ls *ls = lkb->lkb_resource->res_ls;

	struct dlm_rsb *rsb = lkb->lkb_resource;

	struct dlm_ls *ls = rsb->res_ls;

	struct dlm_callback *cb;

	int rv;
@@ -133,34 +175,36 @@ void dlm_add_cb(struct dlm_lkb *lkb, uint32_t flags, int mode, int status, 
		return;

	}



	rv = dlm_queue_lkb_callback(lkb, flags, mode, status, sbflags,

				    &cb);

	switch (rv) {

	case DLM_ENQUEUE_CALLBACK_NEED_SCHED:

		cb->astfn = lkb->lkb_astfn;

		cb->bastfn = lkb->lkb_bastfn;

		cb->astparam = lkb->lkb_astparam;

		INIT_WORK(&cb->work, dlm_callback_work);

	if (dlm_may_skip_callback(lkb, flags, mode, status, sbflags, NULL))

		return;



	spin_lock_bh(&ls->ls_cb_lock);

		if (test_bit(LSFL_CB_DELAY, &ls->ls_flags))

	if (test_bit(LSFL_CB_DELAY, &ls->ls_flags)) {

		rv = dlm_get_queue_cb(lkb, flags, mode, status, sbflags, &cb);

		if (!rv)

			list_add(&cb->list, &ls->ls_cb_delay);

		else

	} else {

		if (test_bit(LSFL_SOFTIRQ, &ls->ls_flags)) {

			dlm_run_callback(ls->ls_global_id, lkb->lkb_id, mode, flags,

					 sbflags, status, lkb->lkb_lksb,

					 lkb->lkb_astfn, lkb->lkb_bastfn,

					 lkb->lkb_astparam, rsb->res_name,

					 rsb->res_length);

		} else {

			rv = dlm_get_queue_cb(lkb, flags, mode, status, sbflags, &cb);

			if (!rv)

				queue_work(ls->ls_callback_wq, &cb->work);

		spin_unlock_bh(&ls->ls_cb_lock);

		break;

	case DLM_ENQUEUE_CALLBACK_SUCCESS:

		break;

	case DLM_ENQUEUE_CALLBACK_FAILURE:

		fallthrough;

	default:

		WARN_ON_ONCE(1);

		break;

		}

	}

	spin_unlock_bh(&ls->ls_cb_lock);

}



int dlm_callback_start(struct dlm_ls *ls)

{

	if (!test_bit(LSFL_FS, &ls->ls_flags) ||

	    test_bit(LSFL_SOFTIRQ, &ls->ls_flags))

		return 0;



	ls->ls_callback_wq = alloc_ordered_workqueue("dlm_callback",

						     WQ_HIGHPRI | WQ_MEM_RECLAIM);

	if (!ls->ls_callback_wq) {
@@ -178,14 +222,16 @@ void dlm_callback_stop(struct dlm_ls *ls) 


void dlm_callback_suspend(struct dlm_ls *ls)

{

	if (ls->ls_callback_wq) {

	if (!test_bit(LSFL_FS, &ls->ls_flags))

		return;



	spin_lock_bh(&ls->ls_cb_lock);

	set_bit(LSFL_CB_DELAY, &ls->ls_flags);

	spin_unlock_bh(&ls->ls_cb_lock);



	if (ls->ls_callback_wq)

		flush_workqueue(ls->ls_callback_wq);

}

}



#define MAX_CB_QUEUE 25
@@ -195,14 +241,18 @@ void dlm_callback_resume(struct dlm_ls *ls) 
	int count = 0, sum = 0;

	bool empty;



	if (!ls->ls_callback_wq)

	if (!test_bit(LSFL_FS, &ls->ls_flags))

		return;



more:

	spin_lock_bh(&ls->ls_cb_lock);

	list_for_each_entry_safe(cb, safe, &ls->ls_cb_delay, list) {

		list_del(&cb->list);

		if (test_bit(LSFL_SOFTIRQ, &ls->ls_flags))

			dlm_do_callback(cb);

		else

			queue_work(ls->ls_callback_wq, &cb->work);



		count++;

		if (count == MAX_CB_QUEUE)

			break;

fs/dlm/ast.h

+5 −6
Original line number Diff line number Diff line
@@ -11,10 +11,9 @@ 
#ifndef __ASTD_DOT_H__

#define __ASTD_DOT_H__



#define DLM_ENQUEUE_CALLBACK_NEED_SCHED	1

#define DLM_ENQUEUE_CALLBACK_SUCCESS	0

#define DLM_ENQUEUE_CALLBACK_FAILURE	-1

int dlm_queue_lkb_callback(struct dlm_lkb *lkb, uint32_t flags, int mode,

bool dlm_may_skip_callback(struct dlm_lkb *lkb, uint32_t flags, int mode,

			   int status, uint32_t sbflags, int *copy_lvb);

int dlm_get_cb(struct dlm_lkb *lkb, uint32_t flags, int mode,

	       int status, uint32_t sbflags,

	       struct dlm_callback **cb);

void dlm_add_cb(struct dlm_lkb *lkb, uint32_t flags, int mode, int status,

fs/dlm/config.c

+1 −1
Original line number Diff line number Diff line
@@ -672,7 +672,7 @@ static ssize_t comm_addr_store(struct config_item *item, const char *buf, 


	memcpy(addr, buf, len);



	rv = dlm_midcomms_addr(cm->nodeid, addr, len);

	rv = dlm_midcomms_addr(cm->nodeid, addr);

	if (rv) {

		kfree(addr);

		return rv;

fs/dlm/debug_fs.c

+5 −5
Original line number Diff line number Diff line
@@ -380,7 +380,7 @@ static const struct seq_operations format4_seq_ops; 


static int table_seq_show(struct seq_file *seq, void *iter_ptr)

{

	struct dlm_rsb *rsb = list_entry(iter_ptr, struct dlm_rsb, res_rsbs_list);

	struct dlm_rsb *rsb = list_entry(iter_ptr, struct dlm_rsb, res_slow_list);



	if (seq->op == &format1_seq_ops)

		print_format1(rsb, seq);
@@ -409,9 +409,9 @@ static void *table_seq_start(struct seq_file *seq, loff_t *pos) 
	}



	if (seq->op == &format4_seq_ops)

		list = &ls->ls_toss;

		list = &ls->ls_slow_inactive;

	else

		list = &ls->ls_keep;

		list = &ls->ls_slow_active;



	read_lock_bh(&ls->ls_rsbtbl_lock);

	return seq_list_start(list, *pos);
@@ -423,9 +423,9 @@ static void *table_seq_next(struct seq_file *seq, void *iter_ptr, loff_t *pos) 
	struct list_head *list;



	if (seq->op == &format4_seq_ops)

		list = &ls->ls_toss;

		list = &ls->ls_slow_inactive;

	else

		list = &ls->ls_keep;

		list = &ls->ls_slow_active;



	return seq_list_next(iter_ptr, list, pos);

}