Commit | Line | Data |
---|---|---|
3bd94003 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
fd5e0339 KU |
2 | /* |
3 | * Copyright (C) 2004-2005 IBM Corp. All Rights Reserved. | |
4 | * Copyright (C) 2006-2009 NEC Corporation. | |
5 | * | |
6 | * dm-queue-length.c | |
7 | * | |
8 | * Module Author: Stefan Bader, IBM | |
9 | * Modified by: Kiyoshi Ueda, NEC | |
10 | * | |
11 | * This file is released under the GPL. | |
12 | * | |
13 | * queue-length path selector - choose a path with the least number of | |
14 | * in-flight I/Os. | |
15 | */ | |
16 | ||
17 | #include "dm.h" | |
18 | #include "dm-path-selector.h" | |
19 | ||
20 | #include <linux/slab.h> | |
21 | #include <linux/ctype.h> | |
22 | #include <linux/errno.h> | |
23 | #include <linux/module.h> | |
60063497 | 24 | #include <linux/atomic.h> |
fd5e0339 KU |
25 | |
26 | #define DM_MSG_PREFIX "multipath queue-length" | |
21136f89 MS |
27 | #define QL_MIN_IO 1 |
28 | #define QL_VERSION "0.2.0" | |
fd5e0339 KU |
29 | |
30 | struct selector { | |
31 | struct list_head valid_paths; | |
32 | struct list_head failed_paths; | |
9659f811 | 33 | spinlock_t lock; |
fd5e0339 KU |
34 | }; |
35 | ||
36 | struct path_info { | |
37 | struct list_head list; | |
38 | struct dm_path *path; | |
86a3238c | 39 | unsigned int repeat_count; |
fd5e0339 KU |
40 | atomic_t qlen; /* the number of in-flight I/Os */ |
41 | }; | |
42 | ||
43 | static struct selector *alloc_selector(void) | |
44 | { | |
45 | struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL); | |
46 | ||
47 | if (s) { | |
48 | INIT_LIST_HEAD(&s->valid_paths); | |
49 | INIT_LIST_HEAD(&s->failed_paths); | |
9659f811 | 50 | spin_lock_init(&s->lock); |
fd5e0339 KU |
51 | } |
52 | ||
53 | return s; | |
54 | } | |
55 | ||
86a3238c | 56 | static int ql_create(struct path_selector *ps, unsigned int argc, char **argv) |
fd5e0339 KU |
57 | { |
58 | struct selector *s = alloc_selector(); | |
59 | ||
60 | if (!s) | |
61 | return -ENOMEM; | |
62 | ||
63 | ps->context = s; | |
64 | return 0; | |
65 | } | |
66 | ||
67 | static void ql_free_paths(struct list_head *paths) | |
68 | { | |
69 | struct path_info *pi, *next; | |
70 | ||
71 | list_for_each_entry_safe(pi, next, paths, list) { | |
72 | list_del(&pi->list); | |
73 | kfree(pi); | |
74 | } | |
75 | } | |
76 | ||
77 | static void ql_destroy(struct path_selector *ps) | |
78 | { | |
79 | struct selector *s = ps->context; | |
80 | ||
81 | ql_free_paths(&s->valid_paths); | |
82 | ql_free_paths(&s->failed_paths); | |
83 | kfree(s); | |
84 | ps->context = NULL; | |
85 | } | |
86 | ||
87 | static int ql_status(struct path_selector *ps, struct dm_path *path, | |
86a3238c | 88 | status_type_t type, char *result, unsigned int maxlen) |
fd5e0339 | 89 | { |
86a3238c | 90 | unsigned int sz = 0; |
fd5e0339 KU |
91 | struct path_info *pi; |
92 | ||
93 | /* When called with NULL path, return selector status/args. */ | |
94 | if (!path) | |
95 | DMEMIT("0 "); | |
96 | else { | |
97 | pi = path->pscontext; | |
98 | ||
99 | switch (type) { | |
100 | case STATUSTYPE_INFO: | |
101 | DMEMIT("%d ", atomic_read(&pi->qlen)); | |
102 | break; | |
103 | case STATUSTYPE_TABLE: | |
104 | DMEMIT("%u ", pi->repeat_count); | |
105 | break; | |
8ec45662 TS |
106 | case STATUSTYPE_IMA: |
107 | *result = '\0'; | |
108 | break; | |
fd5e0339 KU |
109 | } |
110 | } | |
111 | ||
112 | return sz; | |
113 | } | |
114 | ||
115 | static int ql_add_path(struct path_selector *ps, struct dm_path *path, | |
116 | int argc, char **argv, char **error) | |
117 | { | |
118 | struct selector *s = ps->context; | |
119 | struct path_info *pi; | |
86a3238c | 120 | unsigned int repeat_count = QL_MIN_IO; |
31998ef1 | 121 | char dummy; |
9659f811 | 122 | unsigned long flags; |
fd5e0339 KU |
123 | |
124 | /* | |
125 | * Arguments: [<repeat_count>] | |
8ca817c4 HM |
126 | * <repeat_count>: The number of I/Os before switching path. |
127 | * If not given, default (QL_MIN_IO) is used. | |
fd5e0339 KU |
128 | */ |
129 | if (argc > 1) { | |
130 | *error = "queue-length ps: incorrect number of arguments"; | |
131 | return -EINVAL; | |
132 | } | |
133 | ||
31998ef1 | 134 | if ((argc == 1) && (sscanf(argv[0], "%u%c", &repeat_count, &dummy) != 1)) { |
fd5e0339 KU |
135 | *error = "queue-length ps: invalid repeat count"; |
136 | return -EINVAL; | |
137 | } | |
138 | ||
21136f89 MS |
139 | if (repeat_count > 1) { |
140 | DMWARN_LIMIT("repeat_count > 1 is deprecated, using 1 instead"); | |
141 | repeat_count = 1; | |
142 | } | |
143 | ||
fd5e0339 KU |
144 | /* Allocate the path information structure */ |
145 | pi = kmalloc(sizeof(*pi), GFP_KERNEL); | |
146 | if (!pi) { | |
147 | *error = "queue-length ps: Error allocating path information"; | |
148 | return -ENOMEM; | |
149 | } | |
150 | ||
151 | pi->path = path; | |
152 | pi->repeat_count = repeat_count; | |
153 | atomic_set(&pi->qlen, 0); | |
154 | ||
155 | path->pscontext = pi; | |
156 | ||
9659f811 | 157 | spin_lock_irqsave(&s->lock, flags); |
fd5e0339 | 158 | list_add_tail(&pi->list, &s->valid_paths); |
9659f811 | 159 | spin_unlock_irqrestore(&s->lock, flags); |
fd5e0339 KU |
160 | |
161 | return 0; | |
162 | } | |
163 | ||
164 | static void ql_fail_path(struct path_selector *ps, struct dm_path *path) | |
165 | { | |
166 | struct selector *s = ps->context; | |
167 | struct path_info *pi = path->pscontext; | |
9659f811 | 168 | unsigned long flags; |
fd5e0339 | 169 | |
9659f811 | 170 | spin_lock_irqsave(&s->lock, flags); |
fd5e0339 | 171 | list_move(&pi->list, &s->failed_paths); |
9659f811 | 172 | spin_unlock_irqrestore(&s->lock, flags); |
fd5e0339 KU |
173 | } |
174 | ||
175 | static int ql_reinstate_path(struct path_selector *ps, struct dm_path *path) | |
176 | { | |
177 | struct selector *s = ps->context; | |
178 | struct path_info *pi = path->pscontext; | |
9659f811 | 179 | unsigned long flags; |
fd5e0339 | 180 | |
9659f811 | 181 | spin_lock_irqsave(&s->lock, flags); |
fd5e0339 | 182 | list_move_tail(&pi->list, &s->valid_paths); |
9659f811 | 183 | spin_unlock_irqrestore(&s->lock, flags); |
fd5e0339 KU |
184 | |
185 | return 0; | |
186 | } | |
187 | ||
188 | /* | |
189 | * Select a path having the minimum number of in-flight I/Os | |
190 | */ | |
90a4323c | 191 | static struct dm_path *ql_select_path(struct path_selector *ps, size_t nr_bytes) |
fd5e0339 KU |
192 | { |
193 | struct selector *s = ps->context; | |
194 | struct path_info *pi = NULL, *best = NULL; | |
9659f811 MS |
195 | struct dm_path *ret = NULL; |
196 | unsigned long flags; | |
fd5e0339 | 197 | |
9659f811 | 198 | spin_lock_irqsave(&s->lock, flags); |
fd5e0339 | 199 | if (list_empty(&s->valid_paths)) |
9659f811 | 200 | goto out; |
fd5e0339 | 201 | |
fd5e0339 KU |
202 | list_for_each_entry(pi, &s->valid_paths, list) { |
203 | if (!best || | |
204 | (atomic_read(&pi->qlen) < atomic_read(&best->qlen))) | |
205 | best = pi; | |
206 | ||
207 | if (!atomic_read(&best->qlen)) | |
208 | break; | |
209 | } | |
210 | ||
211 | if (!best) | |
9659f811 | 212 | goto out; |
fd5e0339 | 213 | |
f2042605 KK |
214 | /* Move most recently used to least preferred to evenly balance. */ |
215 | list_move_tail(&best->list, &s->valid_paths); | |
216 | ||
9659f811 MS |
217 | ret = best->path; |
218 | out: | |
219 | spin_unlock_irqrestore(&s->lock, flags); | |
220 | return ret; | |
fd5e0339 KU |
221 | } |
222 | ||
223 | static int ql_start_io(struct path_selector *ps, struct dm_path *path, | |
224 | size_t nr_bytes) | |
225 | { | |
226 | struct path_info *pi = path->pscontext; | |
227 | ||
228 | atomic_inc(&pi->qlen); | |
229 | ||
230 | return 0; | |
231 | } | |
232 | ||
233 | static int ql_end_io(struct path_selector *ps, struct dm_path *path, | |
087615bf | 234 | size_t nr_bytes, u64 start_time) |
fd5e0339 KU |
235 | { |
236 | struct path_info *pi = path->pscontext; | |
237 | ||
238 | atomic_dec(&pi->qlen); | |
239 | ||
240 | return 0; | |
241 | } | |
242 | ||
243 | static struct path_selector_type ql_ps = { | |
244 | .name = "queue-length", | |
245 | .module = THIS_MODULE, | |
246 | .table_args = 1, | |
247 | .info_args = 1, | |
248 | .create = ql_create, | |
249 | .destroy = ql_destroy, | |
250 | .status = ql_status, | |
251 | .add_path = ql_add_path, | |
252 | .fail_path = ql_fail_path, | |
253 | .reinstate_path = ql_reinstate_path, | |
254 | .select_path = ql_select_path, | |
255 | .start_io = ql_start_io, | |
256 | .end_io = ql_end_io, | |
257 | }; | |
258 | ||
259 | static int __init dm_ql_init(void) | |
260 | { | |
261 | int r = dm_register_path_selector(&ql_ps); | |
262 | ||
263 | if (r < 0) | |
264 | DMERR("register failed %d", r); | |
265 | ||
266 | DMINFO("version " QL_VERSION " loaded"); | |
267 | ||
268 | return r; | |
269 | } | |
270 | ||
271 | static void __exit dm_ql_exit(void) | |
272 | { | |
273 | int r = dm_unregister_path_selector(&ql_ps); | |
274 | ||
275 | if (r < 0) | |
276 | DMERR("unregister failed %d", r); | |
277 | } | |
278 | ||
279 | module_init(dm_ql_init); | |
280 | module_exit(dm_ql_exit); | |
281 | ||
282 | MODULE_AUTHOR("Stefan Bader <Stefan.Bader at de.ibm.com>"); | |
283 | MODULE_DESCRIPTION( | |
284 | "(C) Copyright IBM Corp. 2004,2005 All Rights Reserved.\n" | |
285 | DM_NAME " path selector to balance the number of in-flight I/Os" | |
286 | ); | |
287 | MODULE_LICENSE("GPL"); |