03-add-modular-pg.patch - a place to put vendor specific junk. I will resend my
FAStT code ported to a priority-group, and seperate new group that should do the
failover for HP-storage-works.
Makefile | 2
dm-priority-group.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++++++++
dm-priority-group.h | 123 ++++++++++++++++++
3 files changed, 478 insertions(+), 1 deletion(-)
diff -Naurp linux-2.6.7-rc2/drivers/md/dm-priority-group.c linux-2.6.7-rc2-pg/drivers/md/dm-priority-group.c
--- linux-2.6.7-rc2/drivers/md/dm-priority-group.c 1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.7-rc2-pg/drivers/md/dm-priority-group.c 2004-06-04 03:37:39.938958278 -0700
@@ -0,0 +1,354 @@
+/*
+ * dm-priority-group.c - DM-mpath Priority Group - Priority Groups
+ * are generic way to group your paths together. PGs should init
+ * the paths if needed (implement ->init function to send a
+ * failover command) and decide when to fail a path (how to decode
+ * and/or pass dm-mpath vendor specific sense is unfinished).
+ *
+ * Copyright (C) IBM Corporation, 2004
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111s-1307, USA.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/list.h>
+
+#include "dm.h"
+#include "dm-priority-group.h"
+
+
+/*
+ * code to handle refcounting priority_group_type modules
+ */
+struct pg_internal {
+ struct priority_group_type pgt;
+
+ struct list_head list;
+ long use;
+};
+
+#define pgt_to_pgi(__pgt) container_of((__pgt), struct pg_internal, pgt)
+
+static LIST_HEAD(priority_groups);
+static DECLARE_MUTEX(priority_groups_lock);
+
+struct priority_group_type *__find_priority_group_type(const char *name)
+{
+ struct pg_internal *pgi;
+
+ list_for_each_entry (pgi, &priority_groups, list) {
+ if (!strcmp(name, pgi->pgt.name))
+ return &pgi->pgt;
+ }
+
+ return NULL;
+}
+
+struct priority_group_type *dm_get_priority_group(const char *name)
+{
+ struct priority_group_type *pgt;
+
+ if (!name)
+ return NULL;
+
+ down(&priority_groups_lock);
+ pgt = __find_priority_group_type(name);
+ if (pgt) {
+ struct pg_internal *pgi = pgt_to_pgi(pgt);
+
+ if (pgi->use == 0 && !try_module_get(pgt->module))
+ pgi = NULL;
+ else
+ pgi->use++;
+ }
+ up(&priority_groups_lock);
+
+ return pgt;
+}
+
+void dm_put_priority_group(struct priority_group_type *pgt)
+{
+ struct pg_internal *pgi;
+
+ down(&priority_groups_lock);
+ pgt = __find_priority_group_type(pgt->name);
+ if (!pgt)
+ return;
+
+ pgi = pgt_to_pgi(pgt);
+ if (--pgi->use == 0)
+ module_put(pgi->pgt.module);
+
+ if (pgi->use < 0)
+ BUG();
+ up(&priority_groups_lock);
+}
+
+static struct pg_internal *_alloc_priority_group(struct priority_group_type *pt)
+{
+ struct pg_internal *pgi = kmalloc(sizeof(*pgi), GFP_KERNEL);
+
+ if (pgi) {
+ memset(pgi, 0, sizeof(*pgi));
+ memcpy(&pgi->pgt, pt, sizeof(*pt));
+ }
+
+ return pgi;
+}
+
+int dm_register_priority_group(struct priority_group_type *pgt)
+{
+ int r = 0;
+ struct pg_internal *pgi = _alloc_priority_group(pgt);
+
+ if (!pgi)
+ return -ENOMEM;
+
+ down(&priority_groups_lock);
+ if (__find_priority_group_type(pgt->name)) {
+ kfree(pgi);
+ r = -EEXIST;
+ } else
+ list_add(&pgi->list, &priority_groups);
+
+ up(&priority_groups_lock);
+
+ return r;
+}
+
+EXPORT_SYMBOL(dm_register_priority_group);
+
+int dm_unregister_priority_group(struct priority_group_type *pgt)
+{
+ struct pg_internal *pgi;
+
+ down(&priority_groups_lock);
+ pgt = __find_priority_group_type(pgt->name);
+ if (!pgt) {
+ up(&priority_groups_lock);
+ return -EINVAL;
+ }
+
+ pgi = pgt_to_pgi(pgt);
+ if (pgi->use) {
+ up(&priority_groups_lock);
+ return -ETXTBSY;
+ }
+
+ list_del(&pgi->list);
+ up(&priority_groups_lock);
+
+ kfree(pgi);
+
+ return 0;
+}
+
+EXPORT_SYMBOL(dm_unregister_priority_group);
+
+
+/*
+ * Generic Priority Group - This handles basic HW or cases where we do
+ * not have any specs/info so we cannot support the devices special
+ * features.
+ */
+
+/* FIXME: get rid of this */
+#define PG_FAIL_COUNT 1
+
+struct path_info {
+ struct list_head list;
+ struct path *path;
+ unsigned fail_count;
+};
+
+/*
+ * bleh - we do not need this. put some sort of private memeber on the
+ * path struct along with nice accessor fns. This is only used in
+ * non critical code paths though.
+ */
+static struct path_info *path_lookup(struct list_head *head, struct path *p)
+{
+ struct path_info *pi;
+
+ list_for_each_entry (pi, head, list)
+ if (pi->path == p)
+ return pi;
+
+ return NULL;
+}
+
+struct pgroup {
+ spinlock_t path_lock;
+
+ struct list_head valid_paths;
+ struct list_head invalid_paths;
+};
+
+static struct pgroup *alloc_pgroup(void)
+{
+ struct pgroup *pgroup = kmalloc(sizeof(*pgroup), GFP_KERNEL);
+
+ if (pgroup) {
+ memset(pgroup, 0, sizeof(*pgroup));
+ INIT_LIST_HEAD(&pgroup->valid_paths);
+ INIT_LIST_HEAD(&pgroup->invalid_paths);
+ pgroup->path_lock = SPIN_LOCK_UNLOCKED;
+ }
+
+ return pgroup;
+}
+
+static int generic_group_ctr(struct priority_group *pg)
+{
+ struct pgroup *pgroup;
+
+ pgroup = alloc_pgroup();
+ if (!pgroup)
+ return -ENOMEM;
+
+ pg->context = pgroup;
+ return 0;
+}
+
+static void free_paths(struct list_head *paths)
+{
+ struct path_info *pi, *next;
+
+ list_for_each_entry_safe (pi, next, paths, list) {
+ list_del(&pi->list);
+ kfree(pi);
+ }
+}
+
+static void generic_group_dtr(struct priority_group *pg)
+{
+ struct pgroup *pgroup = (struct pgroup *)pg->context;
+ free_paths(&pgroup->valid_paths);
+ free_paths(&pgroup->invalid_paths);
+ kfree(pgroup);
+}
+
+static int generic_group_add_path(struct priority_group *pg, struct path *path,
+ int argc, char **argv, char **error)
+{
+ struct pgroup *pgroup= (struct pgroup *) pg->context;
+ struct path_info *pi;
+
+ if (argc != 0) {
+ *error = "generic-pg: incorrect number of arguments";
+ return -EINVAL;
+ }
+
+ pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+ if (!pi) {
+ *error = "generic-pg: Error allocating path context";
+ return -ENOMEM;
+ }
+
+ pi->fail_count = 0;
+ pi->path = path;
+
+ spin_lock(&pgroup->path_lock);
+ list_add_tail(&pi->list, &pgroup->valid_paths);
+ spin_unlock(&pgroup->path_lock);
+
+ return 0;
+}
+
+static int generic_group_update_path(struct priority_group *pg,
+ struct path *path, int status)
+{
+ unsigned long flags;
+ int r = 0;
+ struct path_info *pi;
+ struct pgroup *pgroup = (struct pgroup *) pg->context;
+
+ spin_lock_irqsave(&pgroup->path_lock, flags);
+
+ if (status) {
+ pi = path_lookup(&pgroup->valid_paths, path);
+ if (!pi)
+ goto done;
+
+ if (++pi->fail_count == PG_FAIL_COUNT) {
+ list_move(&pi->list, &pgroup->invalid_paths);
+
+ r = 1;
+ }
+ } else {
+ pi = path_lookup(&pgroup->invalid_paths, path);
+ if (!pi)
+ goto done;
+
+ list_move(&pi->list, &pgroup->valid_paths);
+ }
+
+ done:
+ spin_unlock_irqrestore(&pgroup->path_lock, flags);
+
+ return r;
+}
+
+
+static int generic_group_status(struct priority_group *pg, struct path *path,
+ status_type_t type, char *result,
+ unsigned int maxlen)
+{
+ unsigned long flags;
+ int failed = 0;
+ struct path_info *pi;
+ int sz = 0;
+ struct pgroup *pgroup = (struct pgroup *) pg->context;
+
+ if (type == STATUSTYPE_TABLE)
+ return 0;
+
+ spin_lock_irqsave(&pgroup->path_lock, flags);
+
+ pi = path_lookup(&pgroup->valid_paths, path);
+ if (!pi) {
+ failed = 1;
+ pi = path_lookup(&pgroup->invalid_paths, path);
+ }
+
+ sz = scnprintf(result, maxlen, "%s %u ", failed ? "F" : "A",
+ pi->fail_count);
+
+ spin_unlock_irqrestore(&pgroup->path_lock, flags);
+
+ return sz;
+}
+
+static struct priority_group_type gen_pg = {
+ .name = "generic",
+ .module = THIS_MODULE,
+
+ .ctr = generic_group_ctr,
+ .dtr = generic_group_dtr,
+ .add_path = generic_group_add_path,
+ .update_path = generic_group_update_path,
+ .status = generic_group_status,
+};
+
+int __init dm_register_generic_group(void)
+{
+ return dm_register_priority_group(&gen_pg);
+}
+
+void __exit dm_unregister_generic_group(void)
+{
+ dm_unregister_priority_group(&gen_pg);
+}
diff -Naurp linux-2.6.7-rc2/drivers/md/dm-priority-group.h linux-2.6.7-rc2-pg/drivers/md/dm-priority-group.h
--- linux-2.6.7-rc2/drivers/md/dm-priority-group.h 1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.7-rc2-pg/drivers/md/dm-priority-group.h 2004-06-04 01:55:44.000000000 -0700
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) IBM Corporation, 2004
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111s-1307, USA.
+ *
+ */
+
+#ifndef DM_PRIORITY_GROUP_H
+#define DM_PRIORITY_GROUP_H
+
+#include "dm-path-selector.h"
+
+struct path;
+
+struct block_device *dm_path_to_bdev(struct path *path);
+
+struct multipath;
+struct priority_group_type;
+
+/* Priority Group */
+struct priority_group {
+ /*
+ * This can be set by priority_groups to store
+ * some private data.
+ */
+ void *context;
+
+ /*
+ * These should be considered private to
+ * dm-mpath.c
+ */
+ struct priority_group_type *type;
+ struct path_selector ps;
+ struct multipath *m;
+
+ unsigned nr_paths;
+ struct list_head paths;
+
+ struct list_head list;
+};
+
+/*
+ * Constructs a priority group object, takes custom arguments
+ */
+typedef int (*pg_ctr_fn) (struct priority_group *pg);
+typedef void (*pg_dtr_fn) (struct priority_group *pg);
+
+/*
+ * Allows the pg to initialize itself. It should return one
+ * of the following return values. If DM_PG_INITIALIZING is
+ * returned the priority_group must call dm_pg_init_complete
+ * when the initializtion has completed.
+ */
+enum {
+ DM_PG_SUCCESS,
+ DM_PG_FAILED,
+ DM_PG_INITIALIZING,
+};
+
+void dm_pg_init_complete(struct priority_group *pg);
+
+typedef int (*pg_init_fn) (struct priority_group *pg);
+
+/*
+ * Add a path object, along with some path args.
+ */
+typedef int (*pg_add_path_fn) (struct priority_group *pg, struct path *path,
+ int argc, char **argv, char **error);
+/*
+ * Notify the pg that path status has changes.
+ * status should be an -Exxx value to indicate an error,
+ * 0 to indicatate reactivation.
+ * returns 1 if it determined the path should be
+ * marked as failed else 0.
+ */
+typedef int (*pg_update_path_fn) (struct priority_group *pg,
+ struct path *path, int status);
+
+/*
+ * Table content based on parameters added in pg_add_path_fn
+ * or path selector status
+ */
+typedef int (*pg_status_fn) (struct priority_group *pg, struct path *path,
+ status_type_t type, char *result,
+ unsigned int maxlen);
+
+/* Information about a priority group type */
+struct priority_group_type {
+ char *name;
+ struct module *module;
+
+ unsigned int table_args;
+ unsigned int info_args;
+ pg_ctr_fn ctr;
+ pg_dtr_fn dtr;
+ pg_init_fn init;
+ pg_add_path_fn add_path;
+ pg_update_path_fn update_path;
+ pg_status_fn status;
+};
+
+
+int dm_unregister_priority_group(struct priority_group_type *pgt);
+int dm_register_priority_group(struct priority_group_type *pgt);
+void dm_put_priority_group(struct priority_group_type *pgt);
+struct priority_group_type *dm_get_priority_group(const char *name);
+
+int dm_register_generic_group(void);
+void dm_unregister_generic_group(void);
+
+#endif
diff -Naurp linux-2.6.7-rc2/drivers/md/Makefile linux-2.6.7-rc2-pg/drivers/md/Makefile
--- linux-2.6.7-rc2/drivers/md/Makefile 2004-06-04 03:52:23.168748837 -0700
+++ linux-2.6.7-rc2-pg/drivers/md/Makefile 2004-06-04 03:59:16.659899173 -0700
@@ -4,7 +4,7 @@
dm-mod-objs := dm.o dm-table.o dm-target.o dm-linear.o dm-stripe.o \
dm-ioctl.o dm-io.o kcopyd.o
-dm-multipath-objs := dm-path-selector.o dm-mpath.o
+dm-multipath-objs := dm-path-selector.o dm-priority-group.o dm-mpath.o
dm-snapshot-objs := dm-snap.o dm-exception-store.o
dm-mirror-objs := dm-log.o dm-raid1.o
raid6-objs := raid6main.o raid6algos.o raid6recov.o raid6tables.o \
