1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020 Oracle Corporation 4 * 5 * Module Author: Mike Christie 6 */ 7 #include "dm-path-selector.h" 8 9 #include <linux/device-mapper.h> 10 #include <linux/module.h> 11 12 #define DM_MSG_PREFIX "multipath io-affinity" 13 14 struct path_info { 15 struct dm_path *path; 16 cpumask_var_t cpumask; 17 refcount_t refcount; 18 bool failed; 19 }; 20 21 struct selector { 22 struct path_info **path_map; 23 cpumask_var_t path_mask; 24 atomic_t map_misses; 25 }; 26 27 static void ioa_free_path(struct selector *s, unsigned int cpu) 28 { 29 struct path_info *pi = s->path_map[cpu]; 30 31 if (!pi) 32 return; 33 34 if (refcount_dec_and_test(&pi->refcount)) { 35 cpumask_clear_cpu(cpu, s->path_mask); 36 free_cpumask_var(pi->cpumask); 37 kfree(pi); 38 39 s->path_map[cpu] = NULL; 40 } 41 } 42 43 static int ioa_add_path(struct path_selector *ps, struct dm_path *path, 44 int argc, char **argv, char **error) 45 { 46 struct selector *s = ps->context; 47 struct path_info *pi = NULL; 48 unsigned int cpu; 49 int ret; 50 51 if (argc != 1) { 52 *error = "io-affinity ps: invalid number of arguments"; 53 return -EINVAL; 54 } 55 56 pi = kzalloc(sizeof(*pi), GFP_KERNEL); 57 if (!pi) { 58 *error = "io-affinity ps: Error allocating path context"; 59 return -ENOMEM; 60 } 61 62 pi->path = path; 63 path->pscontext = pi; 64 refcount_set(&pi->refcount, 1); 65 66 if (!zalloc_cpumask_var(&pi->cpumask, GFP_KERNEL)) { 67 *error = "io-affinity ps: Error allocating cpumask context"; 68 ret = -ENOMEM; 69 goto free_pi; 70 } 71 72 ret = cpumask_parse(argv[0], pi->cpumask); 73 if (ret) { 74 *error = "io-affinity ps: invalid cpumask"; 75 ret = -EINVAL; 76 goto free_mask; 77 } 78 79 for_each_cpu(cpu, pi->cpumask) { 80 if (cpu >= nr_cpu_ids) { 81 DMWARN_LIMIT("Ignoring mapping for CPU %u. Max CPU is %u", 82 cpu, nr_cpu_ids); 83 break; 84 } 85 86 if (s->path_map[cpu]) { 87 DMWARN("CPU mapping for %u exists. Ignoring.", cpu); 88 continue; 89 } 90 91 cpumask_set_cpu(cpu, s->path_mask); 92 s->path_map[cpu] = pi; 93 refcount_inc(&pi->refcount); 94 } 95 96 if (refcount_dec_and_test(&pi->refcount)) { 97 *error = "io-affinity ps: No new/valid CPU mapping found"; 98 ret = -EINVAL; 99 goto free_mask; 100 } 101 102 return 0; 103 104 free_mask: 105 free_cpumask_var(pi->cpumask); 106 free_pi: 107 kfree(pi); 108 return ret; 109 } 110 111 static int ioa_create(struct path_selector *ps, unsigned argc, char **argv) 112 { 113 struct selector *s; 114 115 s = kmalloc(sizeof(*s), GFP_KERNEL); 116 if (!s) 117 return -ENOMEM; 118 119 s->path_map = kzalloc(nr_cpu_ids * sizeof(struct path_info *), 120 GFP_KERNEL); 121 if (!s->path_map) 122 goto free_selector; 123 124 if (!zalloc_cpumask_var(&s->path_mask, GFP_KERNEL)) 125 goto free_map; 126 127 atomic_set(&s->map_misses, 0); 128 ps->context = s; 129 return 0; 130 131 free_map: 132 kfree(s->path_map); 133 free_selector: 134 kfree(s); 135 return -ENOMEM; 136 } 137 138 static void ioa_destroy(struct path_selector *ps) 139 { 140 struct selector *s = ps->context; 141 unsigned cpu; 142 143 for_each_cpu(cpu, s->path_mask) 144 ioa_free_path(s, cpu); 145 146 free_cpumask_var(s->path_mask); 147 kfree(s->path_map); 148 kfree(s); 149 150 ps->context = NULL; 151 } 152 153 static int ioa_status(struct path_selector *ps, struct dm_path *path, 154 status_type_t type, char *result, unsigned int maxlen) 155 { 156 struct selector *s = ps->context; 157 struct path_info *pi; 158 int sz = 0; 159 160 if (!path) { 161 DMEMIT("0 "); 162 return sz; 163 } 164 165 switch(type) { 166 case STATUSTYPE_INFO: 167 DMEMIT("%d ", atomic_read(&s->map_misses)); 168 break; 169 case STATUSTYPE_TABLE: 170 pi = path->pscontext; 171 DMEMIT("%*pb ", cpumask_pr_args(pi->cpumask)); 172 break; 173 case STATUSTYPE_IMA: 174 *result = '\0'; 175 break; 176 } 177 178 return sz; 179 } 180 181 static void ioa_fail_path(struct path_selector *ps, struct dm_path *p) 182 { 183 struct path_info *pi = p->pscontext; 184 185 pi->failed = true; 186 } 187 188 static int ioa_reinstate_path(struct path_selector *ps, struct dm_path *p) 189 { 190 struct path_info *pi = p->pscontext; 191 192 pi->failed = false; 193 return 0; 194 } 195 196 static struct dm_path *ioa_select_path(struct path_selector *ps, 197 size_t nr_bytes) 198 { 199 unsigned int cpu, node; 200 struct selector *s = ps->context; 201 const struct cpumask *cpumask; 202 struct path_info *pi; 203 int i; 204 205 cpu = get_cpu(); 206 207 pi = s->path_map[cpu]; 208 if (pi && !pi->failed) 209 goto done; 210 211 /* 212 * Perf is not optimal, but we at least try the local node then just 213 * try not to fail. 214 */ 215 if (!pi) 216 atomic_inc(&s->map_misses); 217 218 node = cpu_to_node(cpu); 219 cpumask = cpumask_of_node(node); 220 for_each_cpu(i, cpumask) { 221 pi = s->path_map[i]; 222 if (pi && !pi->failed) 223 goto done; 224 } 225 226 for_each_cpu(i, s->path_mask) { 227 pi = s->path_map[i]; 228 if (pi && !pi->failed) 229 goto done; 230 } 231 pi = NULL; 232 233 done: 234 put_cpu(); 235 return pi ? pi->path : NULL; 236 } 237 238 static struct path_selector_type ioa_ps = { 239 .name = "io-affinity", 240 .module = THIS_MODULE, 241 .table_args = 1, 242 .info_args = 1, 243 .create = ioa_create, 244 .destroy = ioa_destroy, 245 .status = ioa_status, 246 .add_path = ioa_add_path, 247 .fail_path = ioa_fail_path, 248 .reinstate_path = ioa_reinstate_path, 249 .select_path = ioa_select_path, 250 }; 251 252 static int __init dm_ioa_init(void) 253 { 254 int ret = dm_register_path_selector(&ioa_ps); 255 256 if (ret < 0) 257 DMERR("register failed %d", ret); 258 return ret; 259 } 260 261 static void __exit dm_ioa_exit(void) 262 { 263 int ret = dm_unregister_path_selector(&ioa_ps); 264 265 if (ret < 0) 266 DMERR("unregister failed %d", ret); 267 } 268 269 module_init(dm_ioa_init); 270 module_exit(dm_ioa_exit); 271 272 MODULE_DESCRIPTION(DM_NAME " multipath path selector that selects paths based on the CPU IO is being executed on"); 273 MODULE_AUTHOR("Mike Christie <michael.christie@oracle.com>"); 274 MODULE_LICENSE("GPL"); 275