drivers/md/dm-ps-round-robin.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2003 Sistina Software.
   4  * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
   5  *
   6  * Module Author: Heinz Mauelshagen
   7  *
   8  * This file is released under the GPL.
   9  *
  10  * Round-robin path selector.
  11  */
  12
  13 #include <linux/device-mapper.h>
  14
  15 #include "dm-path-selector.h"
  16
  17 #include <linux/slab.h>
  18 #include <linux/module.h>
  19
  20 #define DM_MSG_PREFIX "multipath round-robin"
  21 #define RR_MIN_IO     1
  22 #define RR_VERSION    "1.2.0"
  23
  24 /*
  25  *---------------------------------------------------------------
  26  * Path-handling code, paths are held in lists
  27  *---------------------------------------------------------------
  28  */
  29 struct path_info {
  30         struct list_head list;
  31         struct dm_path *path;
  32         unsigned int repeat_count;
  33 };
  34
  35 static void free_paths(struct list_head *paths)
  36 {
  37         struct path_info *pi, *next;
  38
  39         list_for_each_entry_safe(pi, next, paths, list) {
  40                 list_del(&pi->list);
  41                 kfree(pi);
  42         }
  43 }
  44
  45 /*
  46  *---------------------------------------------------------------
  47  * Round-robin selector
  48  *---------------------------------------------------------------
  49  */
  50 struct selector {
  51         struct list_head valid_paths;
  52         struct list_head invalid_paths;
  53         spinlock_t lock;
  54 };
  55
  56 static struct selector *alloc_selector(void)
  57 {
  58         struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
  59
  60         if (s) {
  61                 INIT_LIST_HEAD(&s->valid_paths);
  62                 INIT_LIST_HEAD(&s->invalid_paths);
  63                 spin_lock_init(&s->lock);
  64         }
  65
  66         return s;
  67 }
  68
  69 static int rr_create(struct path_selector *ps, unsigned int argc, char **argv)
  70 {
  71         struct selector *s;
  72
  73         s = alloc_selector();
  74         if (!s)
  75                 return -ENOMEM;
  76
  77         ps->context = s;
  78         return 0;
  79 }
  80
  81 static void rr_destroy(struct path_selector *ps)
  82 {
  83         struct selector *s = ps->context;
  84
  85         free_paths(&s->valid_paths);
  86         free_paths(&s->invalid_paths);
  87         kfree(s);
  88         ps->context = NULL;
  89 }
  90
  91 static int rr_status(struct path_selector *ps, struct dm_path *path,
  92                      status_type_t type, char *result, unsigned int maxlen)
  93 {
  94         struct path_info *pi;
  95         int sz = 0;
  96
  97         if (!path)
  98                 DMEMIT("0 ");
  99         else {
 100                 switch (type) {
 101                 case STATUSTYPE_INFO:
 102                         break;
 103                 case STATUSTYPE_TABLE:
 104                         pi = path->pscontext;
 105                         DMEMIT("%u ", pi->repeat_count);
 106                         break;
 107
 108                 case STATUSTYPE_IMA:
 109                         *result = '\0';
 110                         break;
 111                 }
 112         }
 113
 114         return sz;
 115 }
 116
 117 /*
 118  * Called during initialisation to register each path with an
 119  * optional repeat_count.
 120  */
 121 static int rr_add_path(struct path_selector *ps, struct dm_path *path,
 122                        int argc, char **argv, char **error)
 123 {
 124         struct selector *s = ps->context;
 125         struct path_info *pi;
 126         unsigned int repeat_count = RR_MIN_IO;
 127         char dummy;
 128         unsigned long flags;
 129
 130         if (argc > 1) {
 131                 *error = "round-robin ps: incorrect number of arguments";
 132                 return -EINVAL;
 133         }
 134
 135         /* First path argument is number of I/Os before switching path */
 136         if ((argc == 1) && (sscanf(argv[0], "%u%c", &repeat_count, &dummy) != 1)) {
 137                 *error = "round-robin ps: invalid repeat count";
 138                 return -EINVAL;
 139         }
 140
 141         if (repeat_count > 1) {
 142                 DMWARN_LIMIT("repeat_count > 1 is deprecated, using 1 instead");
 143                 repeat_count = 1;
 144         }
 145
 146         /* allocate the path */
 147         pi = kmalloc(sizeof(*pi), GFP_KERNEL);
 148         if (!pi) {
 149                 *error = "round-robin ps: Error allocating path context";
 150                 return -ENOMEM;
 151         }
 152
 153         pi->path = path;
 154         pi->repeat_count = repeat_count;
 155
 156         path->pscontext = pi;
 157
 158         spin_lock_irqsave(&s->lock, flags);
 159         list_add_tail(&pi->list, &s->valid_paths);
 160         spin_unlock_irqrestore(&s->lock, flags);
 161
 162         return 0;
 163 }
 164
 165 static void rr_fail_path(struct path_selector *ps, struct dm_path *p)
 166 {
 167         unsigned long flags;
 168         struct selector *s = ps->context;
 169         struct path_info *pi = p->pscontext;
 170
 171         spin_lock_irqsave(&s->lock, flags);
 172         list_move(&pi->list, &s->invalid_paths);
 173         spin_unlock_irqrestore(&s->lock, flags);
 174 }
 175
 176 static int rr_reinstate_path(struct path_selector *ps, struct dm_path *p)
 177 {
 178         unsigned long flags;
 179         struct selector *s = ps->context;
 180         struct path_info *pi = p->pscontext;
 181
 182         spin_lock_irqsave(&s->lock, flags);
 183         list_move(&pi->list, &s->valid_paths);
 184         spin_unlock_irqrestore(&s->lock, flags);
 185
 186         return 0;
 187 }
 188
 189 static struct dm_path *rr_select_path(struct path_selector *ps, size_t nr_bytes)
 190 {
 191         unsigned long flags;
 192         struct selector *s = ps->context;
 193         struct path_info *pi = NULL;
 194
 195         spin_lock_irqsave(&s->lock, flags);
 196         if (!list_empty(&s->valid_paths)) {
 197                 pi = list_entry(s->valid_paths.next, struct path_info, list);
 198                 list_move_tail(&pi->list, &s->valid_paths);
 199         }
 200         spin_unlock_irqrestore(&s->lock, flags);
 201
 202         return pi ? pi->path : NULL;
 203 }
 204
 205 static struct path_selector_type rr_ps = {
 206         .name = "round-robin",
 207         .module = THIS_MODULE,
 208         .table_args = 1,
 209         .info_args = 0,
 210         .create = rr_create,
 211         .destroy = rr_destroy,
 212         .status = rr_status,
 213         .add_path = rr_add_path,
 214         .fail_path = rr_fail_path,
 215         .reinstate_path = rr_reinstate_path,
 216         .select_path = rr_select_path,
 217 };
 218
 219 static int __init dm_rr_init(void)
 220 {
 221         int r = dm_register_path_selector(&rr_ps);
 222
 223         if (r < 0)
 224                 DMERR("register failed %d", r);
 225
 226         DMINFO("version " RR_VERSION " loaded");
 227
 228         return r;
 229 }
 230
 231 static void __exit dm_rr_exit(void)
 232 {
 233         int r = dm_unregister_path_selector(&rr_ps);
 234
 235         if (r < 0)
 236                 DMERR("unregister failed %d", r);
 237 }
 238
 239 module_init(dm_rr_init);
 240 module_exit(dm_rr_exit);
 241
 242 MODULE_DESCRIPTION(DM_NAME " round-robin multipath path selector");
 243 MODULE_AUTHOR("Sistina Software <dm-devel@lists.linux.dev>");
 244 MODULE_LICENSE("GPL");