stackglue.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * stackglue.c
  4 *
  5 * Code which implements an OCFS2 specific interface to underlying
  6 * cluster stacks.
  7 *
  8 * Copyright (C) 2007, 2009 Oracle.  All rights reserved.
  9 */
 10
 11#include <linux/list.h>
 12#include <linux/spinlock.h>
 13#include <linux/string.h>
 14#include <linux/module.h>
 15#include <linux/slab.h>
 16#include <linux/kmod.h>
 17#include <linux/fs.h>
 18#include <linux/kobject.h>
 19#include <linux/sysfs.h>
 20#include <linux/sysctl.h>
 21
 22#include "ocfs2_fs.h"
 23
 24#include "stackglue.h"
 25
 26#define OCFS2_STACK_PLUGIN_O2CB		"o2cb"
 27#define OCFS2_STACK_PLUGIN_USER		"user"
 28#define OCFS2_MAX_HB_CTL_PATH		256
 29
 30static struct ocfs2_protocol_version locking_max_version;
 31static DEFINE_SPINLOCK(ocfs2_stack_lock);
 32static LIST_HEAD(ocfs2_stack_list);
 33static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1];
 34static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
 35
 36/*
 37 * The stack currently in use.  If not null, active_stack->sp_count > 0,
 38 * the module is pinned, and the locking protocol cannot be changed.
 39 */
 40static struct ocfs2_stack_plugin *active_stack;
 41
 42static struct ocfs2_stack_plugin *ocfs2_stack_lookup(const char *name)
 43{
 44	struct ocfs2_stack_plugin *p;
 45
 46	assert_spin_locked(&ocfs2_stack_lock);
 47
 48	list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
 49		if (!strcmp(p->sp_name, name))
 50			return p;
 51	}
 52
 53	return NULL;
 54}
 55
 56static int ocfs2_stack_driver_request(const char *stack_name,
 57				      const char *plugin_name)
 58{
 59	int rc;
 60	struct ocfs2_stack_plugin *p;
 61
 62	spin_lock(&ocfs2_stack_lock);
 63
 64	/*
 65	 * If the stack passed by the filesystem isn't the selected one,
 66	 * we can't continue.
 67	 */
 68	if (strcmp(stack_name, cluster_stack_name)) {
 69		rc = -EBUSY;
 70		goto out;
 71	}
 72
 73	if (active_stack) {
 74		/*
 75		 * If the active stack isn't the one we want, it cannot
 76		 * be selected right now.
 77		 */
 78		if (!strcmp(active_stack->sp_name, plugin_name))
 79			rc = 0;
 80		else
 81			rc = -EBUSY;
 82		goto out;
 83	}
 84
 85	p = ocfs2_stack_lookup(plugin_name);
 86	if (!p || !try_module_get(p->sp_owner)) {
 87		rc = -ENOENT;
 88		goto out;
 89	}
 90
 91	active_stack = p;
 92	rc = 0;
 93
 94out:
 95	/* If we found it, pin it */
 96	if (!rc)
 97		active_stack->sp_count++;
 98
 99	spin_unlock(&ocfs2_stack_lock);
100	return rc;
101}
102
103/*
104 * This function looks up the appropriate stack and makes it active.  If
105 * there is no stack, it tries to load it.  It will fail if the stack still
106 * cannot be found.  It will also fail if a different stack is in use.
107 */
108static int ocfs2_stack_driver_get(const char *stack_name)
109{
110	int rc;
111	char *plugin_name = OCFS2_STACK_PLUGIN_O2CB;
112
113	/*
114	 * Classic stack does not pass in a stack name.  This is
115	 * compatible with older tools as well.
116	 */
117	if (!stack_name || !*stack_name)
118		stack_name = OCFS2_STACK_PLUGIN_O2CB;
119
120	if (strlen(stack_name) != OCFS2_STACK_LABEL_LEN) {
121		printk(KERN_ERR
122		       "ocfs2 passed an invalid cluster stack label: \"%s\"\n",
123		       stack_name);
124		return -EINVAL;
125	}
126
127	/* Anything that isn't the classic stack is a user stack */
128	if (strcmp(stack_name, OCFS2_STACK_PLUGIN_O2CB))
129		plugin_name = OCFS2_STACK_PLUGIN_USER;
130
131	rc = ocfs2_stack_driver_request(stack_name, plugin_name);
132	if (rc == -ENOENT) {
133		request_module("ocfs2_stack_%s", plugin_name);
134		rc = ocfs2_stack_driver_request(stack_name, plugin_name);
135	}
136
137	if (rc == -ENOENT) {
138		printk(KERN_ERR
139		       "ocfs2: Cluster stack driver \"%s\" cannot be found\n",
140		       plugin_name);
141	} else if (rc == -EBUSY) {
142		printk(KERN_ERR
143		       "ocfs2: A different cluster stack is in use\n");
144	}
145
146	return rc;
147}
148
149static void ocfs2_stack_driver_put(void)
150{
151	spin_lock(&ocfs2_stack_lock);
152	BUG_ON(active_stack == NULL);
153	BUG_ON(active_stack->sp_count == 0);
154
155	active_stack->sp_count--;
156	if (!active_stack->sp_count) {
157		module_put(active_stack->sp_owner);
158		active_stack = NULL;
159	}
160	spin_unlock(&ocfs2_stack_lock);
161}
162
163int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin)
164{
165	int rc;
166
167	spin_lock(&ocfs2_stack_lock);
168	if (!ocfs2_stack_lookup(plugin->sp_name)) {
169		plugin->sp_count = 0;
170		plugin->sp_max_proto = locking_max_version;
171		list_add(&plugin->sp_list, &ocfs2_stack_list);
172		printk(KERN_INFO "ocfs2: Registered cluster interface %s\n",
173		       plugin->sp_name);
174		rc = 0;
175	} else {
176		printk(KERN_ERR "ocfs2: Stack \"%s\" already registered\n",
177		       plugin->sp_name);
178		rc = -EEXIST;
179	}
180	spin_unlock(&ocfs2_stack_lock);
181
182	return rc;
183}
184EXPORT_SYMBOL_GPL(ocfs2_stack_glue_register);
185
186void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin)
187{
188	struct ocfs2_stack_plugin *p;
189
190	spin_lock(&ocfs2_stack_lock);
191	p = ocfs2_stack_lookup(plugin->sp_name);
192	if (p) {
193		BUG_ON(p != plugin);
194		BUG_ON(plugin == active_stack);
195		BUG_ON(plugin->sp_count != 0);
196		list_del_init(&plugin->sp_list);
197		printk(KERN_INFO "ocfs2: Unregistered cluster interface %s\n",
198		       plugin->sp_name);
199	} else {
200		printk(KERN_ERR "Stack \"%s\" is not registered\n",
201		       plugin->sp_name);
202	}
203	spin_unlock(&ocfs2_stack_lock);
204}
205EXPORT_SYMBOL_GPL(ocfs2_stack_glue_unregister);
206
207void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto)
208{
209	struct ocfs2_stack_plugin *p;
210
211	spin_lock(&ocfs2_stack_lock);
212	if (memcmp(max_proto, &locking_max_version,
213		   sizeof(struct ocfs2_protocol_version))) {
214		BUG_ON(locking_max_version.pv_major != 0);
215
216		locking_max_version = *max_proto;
217		list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
218			p->sp_max_proto = locking_max_version;
219		}
220	}
221	spin_unlock(&ocfs2_stack_lock);
222}
223EXPORT_SYMBOL_GPL(ocfs2_stack_glue_set_max_proto_version);
224
225
226/*
227 * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take no argument
228 * for the ast and bast functions.  They will pass the lksb to the ast
229 * and bast.  The caller can wrap the lksb with their own structure to
230 * get more information.
231 */
232int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
233		   int mode,
234		   struct ocfs2_dlm_lksb *lksb,
235		   u32 flags,
236		   void *name,
237		   unsigned int namelen)
238{
239	if (!lksb->lksb_conn)
240		lksb->lksb_conn = conn;
241	else
242		BUG_ON(lksb->lksb_conn != conn);
243	return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags,
244					      name, namelen);
245}
246EXPORT_SYMBOL_GPL(ocfs2_dlm_lock);
247
248int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
249		     struct ocfs2_dlm_lksb *lksb,
250		     u32 flags)
251{
252	BUG_ON(lksb->lksb_conn == NULL);
253
254	return active_stack->sp_ops->dlm_unlock(conn, lksb, flags);
255}
256EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock);
257
258int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
259{
260	return active_stack->sp_ops->lock_status(lksb);
261}
262EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status);
263
264int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
265{
266	return active_stack->sp_ops->lvb_valid(lksb);
267}
268EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb_valid);
269
270void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
271{
272	return active_stack->sp_ops->lock_lvb(lksb);
273}
274EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb);
275
276void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
277{
278	active_stack->sp_ops->dump_lksb(lksb);
279}
280EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);
281
282int ocfs2_stack_supports_plocks(void)
283{
284	return active_stack && active_stack->sp_ops->plock;
285}
286EXPORT_SYMBOL_GPL(ocfs2_stack_supports_plocks);
287
288/*
289 * ocfs2_plock() can only be safely called if
290 * ocfs2_stack_supports_plocks() returned true
291 */
292int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino,
293		struct file *file, int cmd, struct file_lock *fl)
294{
295	WARN_ON_ONCE(active_stack->sp_ops->plock == NULL);
296	if (active_stack->sp_ops->plock)
297		return active_stack->sp_ops->plock(conn, ino, file, cmd, fl);
298	return -EOPNOTSUPP;
299}
300EXPORT_SYMBOL_GPL(ocfs2_plock);
301
302int ocfs2_cluster_connect(const char *stack_name,
303			  const char *cluster_name,
304			  int cluster_name_len,
305			  const char *group,
306			  int grouplen,
307			  struct ocfs2_locking_protocol *lproto,
308			  void (*recovery_handler)(int node_num,
309						   void *recovery_data),
310			  void *recovery_data,
311			  struct ocfs2_cluster_connection **conn)
312{
313	int rc = 0;
314	struct ocfs2_cluster_connection *new_conn;
315
316	BUG_ON(group == NULL);
317	BUG_ON(conn == NULL);
318	BUG_ON(recovery_handler == NULL);
319
320	if (grouplen > GROUP_NAME_MAX) {
321		rc = -EINVAL;
322		goto out;
323	}
324
325	if (memcmp(&lproto->lp_max_version, &locking_max_version,
326		   sizeof(struct ocfs2_protocol_version))) {
327		rc = -EINVAL;
328		goto out;
329	}
330
331	new_conn = kzalloc(sizeof(struct ocfs2_cluster_connection),
332			   GFP_KERNEL);
333	if (!new_conn) {
334		rc = -ENOMEM;
335		goto out;
336	}
337
338	strscpy(new_conn->cc_name, group, GROUP_NAME_MAX + 1);
339	new_conn->cc_namelen = grouplen;
340	if (cluster_name_len)
341		strscpy(new_conn->cc_cluster_name, cluster_name,
342			CLUSTER_NAME_MAX + 1);
343	new_conn->cc_cluster_name_len = cluster_name_len;
344	new_conn->cc_recovery_handler = recovery_handler;
345	new_conn->cc_recovery_data = recovery_data;
346
347	new_conn->cc_proto = lproto;
348	/* Start the new connection at our maximum compatibility level */
349	new_conn->cc_version = lproto->lp_max_version;
350
351	/* This will pin the stack driver if successful */
352	rc = ocfs2_stack_driver_get(stack_name);
353	if (rc)
354		goto out_free;
355
356	rc = active_stack->sp_ops->connect(new_conn);
357	if (rc) {
358		ocfs2_stack_driver_put();
359		goto out_free;
360	}
361
362	*conn = new_conn;
363
364out_free:
365	if (rc)
366		kfree(new_conn);
367
368out:
369	return rc;
370}
371EXPORT_SYMBOL_GPL(ocfs2_cluster_connect);
372
373/* The caller will ensure all nodes have the same cluster stack */
374int ocfs2_cluster_connect_agnostic(const char *group,
375				   int grouplen,
376				   struct ocfs2_locking_protocol *lproto,
377				   void (*recovery_handler)(int node_num,
378							    void *recovery_data),
379				   void *recovery_data,
380				   struct ocfs2_cluster_connection **conn)
381{
382	char *stack_name = NULL;
383
384	if (cluster_stack_name[0])
385		stack_name = cluster_stack_name;
386	return ocfs2_cluster_connect(stack_name, NULL, 0, group, grouplen,
387				     lproto, recovery_handler, recovery_data,
388				     conn);
389}
390EXPORT_SYMBOL_GPL(ocfs2_cluster_connect_agnostic);
391
392/* If hangup_pending is 0, the stack driver will be dropped */
393int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
394			     int hangup_pending)
395{
396	int ret;
397
398	BUG_ON(conn == NULL);
399
400	ret = active_stack->sp_ops->disconnect(conn);
401
402	/* XXX Should we free it anyway? */
403	if (!ret) {
404		kfree(conn);
405		if (!hangup_pending)
406			ocfs2_stack_driver_put();
407	}
408
409	return ret;
410}
411EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect);
412
413/*
414 * Leave the group for this filesystem.  This is executed by a userspace
415 * program (stored in ocfs2_hb_ctl_path).
416 */
417static void ocfs2_leave_group(const char *group)
418{
419	int ret;
420	char *argv[5], *envp[3];
421
422	argv[0] = ocfs2_hb_ctl_path;
423	argv[1] = "-K";
424	argv[2] = "-u";
425	argv[3] = (char *)group;
426	argv[4] = NULL;
427
428	/* minimal command environment taken from cpu_run_sbin_hotplug */
429	envp[0] = "HOME=/";
430	envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
431	envp[2] = NULL;
432
433	ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
434	if (ret < 0) {
435		printk(KERN_ERR
436		       "ocfs2: Error %d running user helper "
437		       "\"%s %s %s %s\"\n",
438		       ret, argv[0], argv[1], argv[2], argv[3]);
439	}
440}
441
442/*
443 * Hangup is a required post-umount.  ocfs2-tools software expects the
444 * filesystem to call "ocfs2_hb_ctl" during unmount.  This happens
445 * regardless of whether the DLM got started, so we can't do it
446 * in ocfs2_cluster_disconnect().  The ocfs2_leave_group() function does
447 * the actual work.
448 */
449void ocfs2_cluster_hangup(const char *group, int grouplen)
450{
451	BUG_ON(group == NULL);
452	BUG_ON(group[grouplen] != '\0');
453
454	ocfs2_leave_group(group);
455
456	/* cluster_disconnect() was called with hangup_pending==1 */
457	ocfs2_stack_driver_put();
458}
459EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup);
460
461int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn,
462			    unsigned int *node)
463{
464	return active_stack->sp_ops->this_node(conn, node);
465}
466EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node);
467
468
469/*
470 * Sysfs bits
471 */
472
473static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj,
474					       struct kobj_attribute *attr,
475					       char *buf)
476{
477	ssize_t ret = 0;
478
479	spin_lock(&ocfs2_stack_lock);
480	if (locking_max_version.pv_major)
481		ret = snprintf(buf, PAGE_SIZE, "%u.%u\n",
482			       locking_max_version.pv_major,
483			       locking_max_version.pv_minor);
484	spin_unlock(&ocfs2_stack_lock);
485
486	return ret;
487}
488
489static struct kobj_attribute ocfs2_attr_max_locking_protocol =
490	__ATTR(max_locking_protocol, S_IRUGO,
491	       ocfs2_max_locking_protocol_show, NULL);
492
493static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj,
494						 struct kobj_attribute *attr,
495						 char *buf)
496{
497	ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
498	struct ocfs2_stack_plugin *p;
499
500	spin_lock(&ocfs2_stack_lock);
501	list_for_each_entry(p, &ocfs2_stack_list, sp_list) {
502		ret = snprintf(buf, remain, "%s\n",
503			       p->sp_name);
504		if (ret >= remain) {
505			/* snprintf() didn't fit */
506			total = -E2BIG;
507			break;
508		}
509		total += ret;
510		remain -= ret;
511	}
512	spin_unlock(&ocfs2_stack_lock);
513
514	return total;
515}
516
517static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins =
518	__ATTR(loaded_cluster_plugins, S_IRUGO,
519	       ocfs2_loaded_cluster_plugins_show, NULL);
520
521static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj,
522						struct kobj_attribute *attr,
523						char *buf)
524{
525	ssize_t ret = 0;
526
527	spin_lock(&ocfs2_stack_lock);
528	if (active_stack) {
529		ret = snprintf(buf, PAGE_SIZE, "%s\n",
530			       active_stack->sp_name);
531		if (ret >= PAGE_SIZE)
532			ret = -E2BIG;
533	}
534	spin_unlock(&ocfs2_stack_lock);
535
536	return ret;
537}
538
539static struct kobj_attribute ocfs2_attr_active_cluster_plugin =
540	__ATTR(active_cluster_plugin, S_IRUGO,
541	       ocfs2_active_cluster_plugin_show, NULL);
542
543static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj,
544					struct kobj_attribute *attr,
545					char *buf)
546{
547	ssize_t ret;
548	spin_lock(&ocfs2_stack_lock);
549	ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name);
550	spin_unlock(&ocfs2_stack_lock);
551
552	return ret;
553}
554
555static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj,
556					 struct kobj_attribute *attr,
557					 const char *buf, size_t count)
558{
559	size_t len = count;
560	ssize_t ret;
561
562	if (len == 0)
563		return len;
564
565	if (buf[len - 1] == '\n')
566		len--;
567
568	if ((len != OCFS2_STACK_LABEL_LEN) ||
569	    (strnlen(buf, len) != len))
570		return -EINVAL;
571
572	spin_lock(&ocfs2_stack_lock);
573	if (active_stack) {
574		if (!strncmp(buf, cluster_stack_name, len))
575			ret = count;
576		else
577			ret = -EBUSY;
578	} else {
579		memcpy(cluster_stack_name, buf, len);
580		ret = count;
581	}
582	spin_unlock(&ocfs2_stack_lock);
583
584	return ret;
585}
586
587
588static struct kobj_attribute ocfs2_attr_cluster_stack =
589	__ATTR(cluster_stack, S_IRUGO | S_IWUSR,
590	       ocfs2_cluster_stack_show,
591	       ocfs2_cluster_stack_store);
592
593
594
595static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj,
596					struct kobj_attribute *attr,
597					char *buf)
598{
599	return snprintf(buf, PAGE_SIZE, "1\n");
600}
601
602static struct kobj_attribute ocfs2_attr_dlm_recover_support =
603	__ATTR(dlm_recover_callback_support, S_IRUGO,
604	       ocfs2_dlm_recover_show, NULL);
605
606static struct attribute *ocfs2_attrs[] = {
607	&ocfs2_attr_max_locking_protocol.attr,
608	&ocfs2_attr_loaded_cluster_plugins.attr,
609	&ocfs2_attr_active_cluster_plugin.attr,
610	&ocfs2_attr_cluster_stack.attr,
611	&ocfs2_attr_dlm_recover_support.attr,
612	NULL,
613};
614
615static const struct attribute_group ocfs2_attr_group = {
616	.attrs = ocfs2_attrs,
617};
618
619struct kset *ocfs2_kset;
620EXPORT_SYMBOL_GPL(ocfs2_kset);
621
622static void ocfs2_sysfs_exit(void)
623{
624	kset_unregister(ocfs2_kset);
625}
626
627static int ocfs2_sysfs_init(void)
628{
629	int ret;
630
631	ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj);
632	if (!ocfs2_kset)
633		return -ENOMEM;
634
635	ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group);
636	if (ret)
637		goto error;
638
639	return 0;
640
641error:
642	kset_unregister(ocfs2_kset);
643	return ret;
644}
645
646/*
647 * Sysctl bits
648 *
649 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path.  The 'nm' doesn't
650 * make as much sense in a multiple cluster stack world, but it's safer
651 * and easier to preserve the name.
652 */
653
654static const struct ctl_table ocfs2_nm_table[] = {
655	{
656		.procname	= "hb_ctl_path",
657		.data		= ocfs2_hb_ctl_path,
658		.maxlen		= OCFS2_MAX_HB_CTL_PATH,
659		.mode		= 0644,
660		.proc_handler	= proc_dostring,
661	},
662};
663
664static struct ctl_table_header *ocfs2_table_header;
665
666/*
667 * Initialization
668 */
669
670static int __init ocfs2_stack_glue_init(void)
671{
672	int ret;
673
674	strscpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB);
675
676	ocfs2_table_header = register_sysctl("fs/ocfs2/nm", ocfs2_nm_table);
677	if (!ocfs2_table_header) {
678		printk(KERN_ERR
679		       "ocfs2 stack glue: unable to register sysctl\n");
680		return -ENOMEM; /* or something. */
681	}
682
683	ret = ocfs2_sysfs_init();
684	if (ret)
685		unregister_sysctl_table(ocfs2_table_header);
686
687	return ret;
688}
689
690static void __exit ocfs2_stack_glue_exit(void)
691{
692	memset(&locking_max_version, 0,
693	       sizeof(struct ocfs2_protocol_version));
694	ocfs2_sysfs_exit();
695	unregister_sysctl_table(ocfs2_table_header);
696}
697
698MODULE_AUTHOR("Oracle");
699MODULE_DESCRIPTION("ocfs2 cluster stack glue layer");
700MODULE_LICENSE("GPL");
701module_init(ocfs2_stack_glue_init);
702module_exit(ocfs2_stack_glue_exit);