1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * shadow.c - Shadow Variables 4 * 5 * Copyright (C) 2014 Josh Poimboeuf <jpoimboe@redhat.com> 6 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com> 7 * Copyright (C) 2017 Joe Lawrence <joe.lawrence@redhat.com> 8 */ 9 10 /** 11 * DOC: Shadow variable API concurrency notes: 12 * 13 * The shadow variable API provides a simple relationship between an 14 * <obj, id> pair and a pointer value. It is the responsibility of the 15 * caller to provide any mutual exclusion required of the shadow data. 16 * 17 * Once a shadow variable is attached to its parent object via the 18 * klp_shadow_*alloc() API calls, it is considered live: any subsequent 19 * call to klp_shadow_get() may then return the shadow variable's data 20 * pointer. Callers of klp_shadow_*alloc() should prepare shadow data 21 * accordingly. 22 * 23 * The klp_shadow_*alloc() API calls may allocate memory for new shadow 24 * variable structures. Their implementation does not call kmalloc 25 * inside any spinlocks, but API callers should pass GFP flags according 26 * to their specific needs. 27 * 28 * The klp_shadow_hash is an RCU-enabled hashtable and is safe against 29 * concurrent klp_shadow_free() and klp_shadow_get() operations. 30 */ 31 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 33 34 #include <linux/hashtable.h> 35 #include <linux/slab.h> 36 #include <linux/livepatch.h> 37 38 static DEFINE_HASHTABLE(klp_shadow_hash, 12); 39 40 /* 41 * klp_shadow_lock provides exclusive access to the klp_shadow_hash and 42 * the shadow variables it references. 43 */ 44 static DEFINE_SPINLOCK(klp_shadow_lock); 45 46 /** 47 * struct klp_shadow - shadow variable structure 48 * @node: klp_shadow_hash hash table node 49 * @rcu_head: RCU is used to safely free this structure 50 * @obj: pointer to parent object 51 * @id: data identifier 52 * @data: data area 53 */ 54 struct klp_shadow { 55 struct hlist_node node; 56 struct rcu_head rcu_head; 57 void *obj; 58 unsigned long id; 59 char data[]; 60 }; 61 62 /** 63 * klp_shadow_match() - verify a shadow variable matches given <obj, id> 64 * @shadow: shadow variable to match 65 * @obj: pointer to parent object 66 * @id: data identifier 67 * 68 * Return: true if the shadow variable matches. 69 */ 70 static inline bool klp_shadow_match(struct klp_shadow *shadow, void *obj, 71 unsigned long id) 72 { 73 return shadow->obj == obj && shadow->id == id; 74 } 75 76 /** 77 * klp_shadow_get() - retrieve a shadow variable data pointer 78 * @obj: pointer to parent object 79 * @id: data identifier 80 * 81 * Return: the shadow variable data element, NULL on failure. 82 */ 83 void *klp_shadow_get(void *obj, unsigned long id) 84 { 85 struct klp_shadow *shadow; 86 87 rcu_read_lock(); 88 89 hash_for_each_possible_rcu(klp_shadow_hash, shadow, node, 90 (unsigned long)obj) { 91 92 if (klp_shadow_match(shadow, obj, id)) { 93 rcu_read_unlock(); 94 return shadow->data; 95 } 96 } 97 98 rcu_read_unlock(); 99 100 return NULL; 101 } 102 EXPORT_SYMBOL_GPL(klp_shadow_get); 103 104 static void *__klp_shadow_get_or_alloc(void *obj, unsigned long id, 105 size_t size, gfp_t gfp_flags, 106 klp_shadow_ctor_t ctor, void *ctor_data, 107 bool warn_on_exist) 108 { 109 struct klp_shadow *new_shadow; 110 void *shadow_data; 111 unsigned long flags; 112 113 /* Check if the shadow variable already exists */ 114 shadow_data = klp_shadow_get(obj, id); 115 if (shadow_data) 116 goto exists; 117 118 /* 119 * Allocate a new shadow variable. Fill it with zeroes by default. 120 * More complex setting can be done by @ctor function. But it is 121 * called only when the buffer is really used (under klp_shadow_lock). 122 */ 123 new_shadow = kzalloc(size + sizeof(*new_shadow), gfp_flags); 124 if (!new_shadow) 125 return NULL; 126 127 /* Look for <obj, id> again under the lock */ 128 spin_lock_irqsave(&klp_shadow_lock, flags); 129 shadow_data = klp_shadow_get(obj, id); 130 if (unlikely(shadow_data)) { 131 /* 132 * Shadow variable was found, throw away speculative 133 * allocation. 134 */ 135 spin_unlock_irqrestore(&klp_shadow_lock, flags); 136 kfree(new_shadow); 137 goto exists; 138 } 139 140 new_shadow->obj = obj; 141 new_shadow->id = id; 142 143 if (ctor) { 144 int err; 145 146 err = ctor(obj, new_shadow->data, ctor_data); 147 if (err) { 148 spin_unlock_irqrestore(&klp_shadow_lock, flags); 149 kfree(new_shadow); 150 pr_err("Failed to construct shadow variable <%p, %lx> (%d)\n", 151 obj, id, err); 152 return NULL; 153 } 154 } 155 156 /* No <obj, id> found, so attach the newly allocated one */ 157 hash_add_rcu(klp_shadow_hash, &new_shadow->node, 158 (unsigned long)new_shadow->obj); 159 spin_unlock_irqrestore(&klp_shadow_lock, flags); 160 161 return new_shadow->data; 162 163 exists: 164 if (warn_on_exist) { 165 WARN(1, "Duplicate shadow variable <%p, %lx>\n", obj, id); 166 return NULL; 167 } 168 169 return shadow_data; 170 } 171 172 /** 173 * klp_shadow_alloc() - allocate and add a new shadow variable 174 * @obj: pointer to parent object 175 * @id: data identifier 176 * @size: size of attached data 177 * @gfp_flags: GFP mask for allocation 178 * @ctor: custom constructor to initialize the shadow data (optional) 179 * @ctor_data: pointer to any data needed by @ctor (optional) 180 * 181 * Allocates @size bytes for new shadow variable data using @gfp_flags. 182 * The data are zeroed by default. They are further initialized by @ctor 183 * function if it is not NULL. The new shadow variable is then added 184 * to the global hashtable. 185 * 186 * If an existing <obj, id> shadow variable can be found, this routine will 187 * issue a WARN, exit early and return NULL. 188 * 189 * This function guarantees that the constructor function is called only when 190 * the variable did not exist before. The cost is that @ctor is called 191 * in atomic context under a spin lock. 192 * 193 * Return: the shadow variable data element, NULL on duplicate or 194 * failure. 195 */ 196 void *klp_shadow_alloc(void *obj, unsigned long id, 197 size_t size, gfp_t gfp_flags, 198 klp_shadow_ctor_t ctor, void *ctor_data) 199 { 200 return __klp_shadow_get_or_alloc(obj, id, size, gfp_flags, 201 ctor, ctor_data, true); 202 } 203 EXPORT_SYMBOL_GPL(klp_shadow_alloc); 204 205 /** 206 * klp_shadow_get_or_alloc() - get existing or allocate a new shadow variable 207 * @obj: pointer to parent object 208 * @id: data identifier 209 * @size: size of attached data 210 * @gfp_flags: GFP mask for allocation 211 * @ctor: custom constructor to initialize the shadow data (optional) 212 * @ctor_data: pointer to any data needed by @ctor (optional) 213 * 214 * Returns a pointer to existing shadow data if an <obj, id> shadow 215 * variable is already present. Otherwise, it creates a new shadow 216 * variable like klp_shadow_alloc(). 217 * 218 * This function guarantees that only one shadow variable exists with the given 219 * @id for the given @obj. It also guarantees that the constructor function 220 * will be called only when the variable did not exist before. The cost is 221 * that @ctor is called in atomic context under a spin lock. 222 * 223 * Return: the shadow variable data element, NULL on failure. 224 */ 225 void *klp_shadow_get_or_alloc(void *obj, unsigned long id, 226 size_t size, gfp_t gfp_flags, 227 klp_shadow_ctor_t ctor, void *ctor_data) 228 { 229 return __klp_shadow_get_or_alloc(obj, id, size, gfp_flags, 230 ctor, ctor_data, false); 231 } 232 EXPORT_SYMBOL_GPL(klp_shadow_get_or_alloc); 233 234 static void klp_shadow_free_struct(struct klp_shadow *shadow, 235 klp_shadow_dtor_t dtor) 236 { 237 hash_del_rcu(&shadow->node); 238 if (dtor) 239 dtor(shadow->obj, shadow->data); 240 kfree_rcu(shadow, rcu_head); 241 } 242 243 /** 244 * klp_shadow_free() - detach and free a <obj, id> shadow variable 245 * @obj: pointer to parent object 246 * @id: data identifier 247 * @dtor: custom callback that can be used to unregister the variable 248 * and/or free data that the shadow variable points to (optional) 249 * 250 * This function releases the memory for this <obj, id> shadow variable 251 * instance, callers should stop referencing it accordingly. 252 */ 253 void klp_shadow_free(void *obj, unsigned long id, klp_shadow_dtor_t dtor) 254 { 255 struct klp_shadow *shadow; 256 unsigned long flags; 257 258 spin_lock_irqsave(&klp_shadow_lock, flags); 259 260 /* Delete <obj, id> from hash */ 261 hash_for_each_possible(klp_shadow_hash, shadow, node, 262 (unsigned long)obj) { 263 264 if (klp_shadow_match(shadow, obj, id)) { 265 klp_shadow_free_struct(shadow, dtor); 266 break; 267 } 268 } 269 270 spin_unlock_irqrestore(&klp_shadow_lock, flags); 271 } 272 EXPORT_SYMBOL_GPL(klp_shadow_free); 273 274 /** 275 * klp_shadow_free_all() - detach and free all <*, id> shadow variables 276 * @id: data identifier 277 * @dtor: custom callback that can be used to unregister the variable 278 * and/or free data that the shadow variable points to (optional) 279 * 280 * This function releases the memory for all <*, id> shadow variable 281 * instances, callers should stop referencing them accordingly. 282 */ 283 void klp_shadow_free_all(unsigned long id, klp_shadow_dtor_t dtor) 284 { 285 struct klp_shadow *shadow; 286 unsigned long flags; 287 int i; 288 289 spin_lock_irqsave(&klp_shadow_lock, flags); 290 291 /* Delete all <*, id> from hash */ 292 hash_for_each(klp_shadow_hash, i, shadow, node) { 293 if (klp_shadow_match(shadow, shadow->obj, id)) 294 klp_shadow_free_struct(shadow, dtor); 295 } 296 297 spin_unlock_irqrestore(&klp_shadow_lock, flags); 298 } 299 EXPORT_SYMBOL_GPL(klp_shadow_free_all); 300