core.c 24.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
 * core.c - Kernel Live Patching Core
 *
 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
 * Copyright (C) 2014 SUSE
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/kallsyms.h>
#include <linux/livepatch.h>
30
31
#include <linux/elf.h>
#include <linux/moduleloader.h>
32
#include <linux/completion.h>
33
#include <linux/memory.h>
34
#include <asm/cacheflush.h>
35
#include "core.h"
36
#include "patch.h"
37
#include "transition.h"
38

39
/*
40
41
42
43
44
45
 * klp_mutex is a coarse lock which serializes access to klp data.  All
 * accesses to klp-related variables and structures must have mutex protection,
 * except within the following functions which carefully avoid the need for it:
 *
 * - klp_ftrace_handler()
 * - klp_update_patch_state()
46
 */
47
DEFINE_MUTEX(klp_mutex);
48

49
50
51
52
53
54
55
56
57
58
59
60
static LIST_HEAD(klp_patches);

static struct kobject *klp_root_kobj;

static bool klp_is_module(struct klp_object *obj)
{
	return obj->name;
}

/* sets obj->mod if object is not vmlinux and module is found */
static void klp_find_object_module(struct klp_object *obj)
{
61
62
	struct module *mod;

63
64
65
66
67
	if (!klp_is_module(obj))
		return;

	mutex_lock(&module_mutex);
	/*
68
69
	 * We do not want to block removal of patched modules and therefore
	 * we do not take a reference here. The patches are removed by
70
	 * klp_module_going() instead.
71
72
73
	 */
	mod = find_module(obj->name);
	/*
74
75
	 * Do not mess work of klp_module_coming() and klp_module_going().
	 * Note that the patch might still be needed before klp_module_going()
76
77
78
	 * is called. Module functions can be called even in the GOING state
	 * until mod->exit() finishes. This is especially important for
	 * patches that modify semantic of the functions.
79
	 */
80
81
82
	if (mod && mod->klp_alive)
		obj->mod = mod;

83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
	mutex_unlock(&module_mutex);
}

static bool klp_is_patch_registered(struct klp_patch *patch)
{
	struct klp_patch *mypatch;

	list_for_each_entry(mypatch, &klp_patches, list)
		if (mypatch == patch)
			return true;

	return false;
}

static bool klp_initialized(void)
{
99
	return !!klp_root_kobj;
100
101
102
103
104
105
106
}

struct klp_find_arg {
	const char *objname;
	const char *name;
	unsigned long addr;
	unsigned long count;
107
	unsigned long pos;
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
};

static int klp_find_callback(void *data, const char *name,
			     struct module *mod, unsigned long addr)
{
	struct klp_find_arg *args = data;

	if ((mod && !args->objname) || (!mod && args->objname))
		return 0;

	if (strcmp(args->name, name))
		return 0;

	if (args->objname && strcmp(args->objname, mod->name))
		return 0;

	args->addr = addr;
	args->count++;

127
128
129
130
131
132
133
134
	/*
	 * Finish the search when the symbol is found for the desired position
	 * or the position is not defined for a non-unique symbol.
	 */
	if ((args->pos && (args->count == args->pos)) ||
	    (!args->pos && (args->count > 1)))
		return 1;

135
136
137
138
	return 0;
}

static int klp_find_object_symbol(const char *objname, const char *name,
139
				  unsigned long sympos, unsigned long *addr)
140
141
142
143
144
{
	struct klp_find_arg args = {
		.objname = objname,
		.name = name,
		.addr = 0,
145
146
		.count = 0,
		.pos = sympos,
147
148
	};

149
	mutex_lock(&module_mutex);
150
151
152
153
	if (objname)
		module_kallsyms_on_each_symbol(klp_find_callback, &args);
	else
		kallsyms_on_each_symbol(klp_find_callback, &args);
154
	mutex_unlock(&module_mutex);
155

156
157
158
159
160
	/*
	 * Ensure an address was found. If sympos is 0, ensure symbol is unique;
	 * otherwise ensure the symbol position count matches sympos.
	 */
	if (args.addr == 0)
161
		pr_err("symbol '%s' not found in symbol table\n", name);
162
	else if (args.count > 1 && sympos == 0) {
163
164
		pr_err("unresolvable ambiguity for symbol '%s' in object '%s'\n",
		       name, objname);
165
166
167
168
	} else if (sympos != args.count && sympos > 0) {
		pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n",
		       sympos, name, objname ? objname : "vmlinux");
	} else {
169
170
171
172
173
174
175
176
		*addr = args.addr;
		return 0;
	}

	*addr = 0;
	return -EINVAL;
}

177
static int klp_resolve_symbols(Elf_Shdr *relasec, struct module *pmod)
178
{
179
180
181
182
183
184
185
	int i, cnt, vmlinux, ret;
	char objname[MODULE_NAME_LEN];
	char symname[KSYM_NAME_LEN];
	char *strtab = pmod->core_kallsyms.strtab;
	Elf_Rela *relas;
	Elf_Sym *sym;
	unsigned long sympos, addr;
186

187
	/*
188
189
190
191
192
193
194
195
	 * Since the field widths for objname and symname in the sscanf()
	 * call are hard-coded and correspond to MODULE_NAME_LEN and
	 * KSYM_NAME_LEN respectively, we must make sure that MODULE_NAME_LEN
	 * and KSYM_NAME_LEN have the values we expect them to have.
	 *
	 * Because the value of MODULE_NAME_LEN can differ among architectures,
	 * we use the smallest/strictest upper bound possible (56, based on
	 * the current definition of MODULE_NAME_LEN) to prevent overflows.
196
	 */
197
198
199
200
201
202
203
	BUILD_BUG_ON(MODULE_NAME_LEN < 56 || KSYM_NAME_LEN != 128);

	relas = (Elf_Rela *) relasec->sh_addr;
	/* For each rela in this klp relocation section */
	for (i = 0; i < relasec->sh_size / sizeof(Elf_Rela); i++) {
		sym = pmod->core_kallsyms.symtab + ELF_R_SYM(relas[i].r_info);
		if (sym->st_shndx != SHN_LIVEPATCH) {
204
			pr_err("symbol %s is not marked as a livepatch symbol\n",
205
206
207
208
209
210
211
212
213
			       strtab + sym->st_name);
			return -EINVAL;
		}

		/* Format: .klp.sym.objname.symname,sympos */
		cnt = sscanf(strtab + sym->st_name,
			     ".klp.sym.%55[^.].%127[^,],%lu",
			     objname, symname, &sympos);
		if (cnt != 3) {
214
			pr_err("symbol %s has an incorrectly formatted name\n",
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
			       strtab + sym->st_name);
			return -EINVAL;
		}

		/* klp_find_object_symbol() treats a NULL objname as vmlinux */
		vmlinux = !strcmp(objname, "vmlinux");
		ret = klp_find_object_symbol(vmlinux ? NULL : objname,
					     symname, sympos, &addr);
		if (ret)
			return ret;

		sym->st_value = addr;
	}

	return 0;
230
231
232
233
234
}

static int klp_write_object_relocations(struct module *pmod,
					struct klp_object *obj)
{
235
236
237
238
	int i, cnt, ret = 0;
	const char *objname, *secname;
	char sec_objname[MODULE_NAME_LEN];
	Elf_Shdr *sec;
239
240
241
242

	if (WARN_ON(!klp_is_object_loaded(obj)))
		return -EINVAL;

243
	objname = klp_is_module(obj) ? obj->name : "vmlinux";
244

245
246
247
248
249
250
	/* For each klp relocation section */
	for (i = 1; i < pmod->klp_info->hdr.e_shnum; i++) {
		sec = pmod->klp_info->sechdrs + i;
		secname = pmod->klp_info->secstrings + sec->sh_name;
		if (!(sec->sh_flags & SHF_RELA_LIVEPATCH))
			continue;
251

252
253
254
255
256
257
258
		/*
		 * Format: .klp.rela.sec_objname.section_name
		 * See comment in klp_resolve_symbols() for an explanation
		 * of the selected field width value.
		 */
		cnt = sscanf(secname, ".klp.rela.%55[^.]", sec_objname);
		if (cnt != 1) {
259
			pr_err("section %s has an incorrectly formatted name\n",
260
261
262
263
			       secname);
			ret = -EINVAL;
			break;
		}
264

265
266
		if (strcmp(objname, sec_objname))
			continue;
267

268
		ret = klp_resolve_symbols(sec, pmod);
269
		if (ret)
270
			break;
271

272
273
274
275
276
		ret = apply_relocate_add(pmod->klp_info->sechdrs,
					 pmod->core_kallsyms.strtab,
					 pmod->klp_info->symndx, i, pmod);
		if (ret)
			break;
277
278
	}

279
	return ret;
280
281
282
283
}

static int __klp_disable_patch(struct klp_patch *patch)
{
284
285
	struct klp_object *obj;

286
287
288
	if (WARN_ON(!patch->enabled))
		return -EINVAL;

289
290
	if (klp_transition_patch)
		return -EBUSY;
291

292
293
	/* enforce stacking: only the last enabled patch can be disabled */
	if (!list_is_last(&patch->list, &klp_patches) &&
294
	    list_next_entry(patch, list)->enabled)
295
296
		return -EBUSY;

297
	klp_init_transition(patch, KLP_UNPATCHED);
298

299
	klp_for_each_object(patch, obj)
300
		if (obj->patched)
301
302
			klp_pre_unpatch_callback(obj);

303
304
305
306
307
308
309
310
	/*
	 * Enforce the order of the func->transition writes in
	 * klp_init_transition() and the TIF_PATCH_PENDING writes in
	 * klp_start_transition().  In the rare case where klp_ftrace_handler()
	 * is called shortly after klp_update_patch_state() switches the task,
	 * this ensures the handler sees that func->transition is set.
	 */
	smp_wmb();
311

312
313
	klp_start_transition();
	klp_try_complete_transition();
314
	patch->enabled = false;
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337

	return 0;
}

/**
 * klp_disable_patch() - disables a registered patch
 * @patch:	The registered, enabled patch to be disabled
 *
 * Unregisters the patched functions from ftrace.
 *
 * Return: 0 on success, otherwise error
 */
int klp_disable_patch(struct klp_patch *patch)
{
	int ret;

	mutex_lock(&klp_mutex);

	if (!klp_is_patch_registered(patch)) {
		ret = -EINVAL;
		goto err;
	}

338
	if (!patch->enabled) {
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
		ret = -EINVAL;
		goto err;
	}

	ret = __klp_disable_patch(patch);

err:
	mutex_unlock(&klp_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(klp_disable_patch);

static int __klp_enable_patch(struct klp_patch *patch)
{
	struct klp_object *obj;
	int ret;

356
357
358
	if (klp_transition_patch)
		return -EBUSY;

359
	if (WARN_ON(patch->enabled))
360
361
		return -EINVAL;

362
363
	/* enforce stacking: only the first disabled patch can be enabled */
	if (patch->list.prev != &klp_patches &&
364
	    !list_prev_entry(patch, list)->enabled)
365
366
		return -EBUSY;

367
368
369
370
371
372
373
	/*
	 * A reference is taken on the patch module to prevent it from being
	 * unloaded.
	 */
	if (!try_module_get(patch->mod))
		return -ENODEV;

374
375
	pr_notice("enabling patch '%s'\n", patch->mod->name);

376
377
378
379
380
381
382
383
384
385
386
	klp_init_transition(patch, KLP_PATCHED);

	/*
	 * Enforce the order of the func->transition writes in
	 * klp_init_transition() and the ops->func_stack writes in
	 * klp_patch_object(), so that klp_ftrace_handler() will see the
	 * func->transition updates before the handler is registered and the
	 * new funcs become visible to the handler.
	 */
	smp_wmb();

387
	klp_for_each_object(patch, obj) {
388
389
390
		if (!klp_is_object_loaded(obj))
			continue;

391
		ret = klp_pre_patch_callback(obj);
392
		if (ret) {
393
394
395
396
			pr_warn("pre-patch callback failed for object '%s'\n",
				klp_is_module(obj) ? obj->name : "vmlinux");
			goto err;
		}
397

398
399
400
401
402
		ret = klp_patch_object(obj);
		if (ret) {
			pr_warn("failed to patch object '%s'\n",
				klp_is_module(obj) ? obj->name : "vmlinux");
			goto err;
403
		}
404
405
	}

406
407
	klp_start_transition();
	klp_try_complete_transition();
408
	patch->enabled = true;
409
410

	return 0;
411
412
413
414
415
err:
	pr_warn("failed to enable patch '%s'\n", patch->mod->name);

	klp_cancel_transition();
	return ret;
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
}

/**
 * klp_enable_patch() - enables a registered patch
 * @patch:	The registered, disabled patch to be enabled
 *
 * Performs the needed symbol lookups and code relocations,
 * then registers the patched functions with ftrace.
 *
 * Return: 0 on success, otherwise error
 */
int klp_enable_patch(struct klp_patch *patch)
{
	int ret;

	mutex_lock(&klp_mutex);

	if (!klp_is_patch_registered(patch)) {
		ret = -EINVAL;
		goto err;
	}

	ret = __klp_enable_patch(patch);

err:
	mutex_unlock(&klp_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(klp_enable_patch);

/*
 * Sysfs Interface
 *
 * /sys/kernel/livepatch
 * /sys/kernel/livepatch/<patch>
 * /sys/kernel/livepatch/<patch>/enabled
452
 * /sys/kernel/livepatch/<patch>/transition
453
 * /sys/kernel/livepatch/<patch>/signal
454
 * /sys/kernel/livepatch/<patch>/force
455
 * /sys/kernel/livepatch/<patch>/<object>
456
 * /sys/kernel/livepatch/<patch>/<object>/<function,sympos>
457
458
459
460
461
462
463
 */

static ssize_t enabled_store(struct kobject *kobj, struct kobj_attribute *attr,
			     const char *buf, size_t count)
{
	struct klp_patch *patch;
	int ret;
464
	bool enabled;
465

466
	ret = kstrtobool(buf, &enabled);
467
	if (ret)
468
		return ret;
469
470
471
472
473

	patch = container_of(kobj, struct klp_patch, kobj);

	mutex_lock(&klp_mutex);

474
475
476
477
478
479
480
481
482
	if (!klp_is_patch_registered(patch)) {
		/*
		 * Module with the patch could either disappear meanwhile or is
		 * not properly initialized yet.
		 */
		ret = -EINVAL;
		goto err;
	}

483
	if (patch->enabled == enabled) {
484
485
486
487
488
		/* already in requested state */
		ret = -EINVAL;
		goto err;
	}

489
490
491
	if (patch == klp_transition_patch) {
		klp_reverse_transition();
	} else if (enabled) {
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
		ret = __klp_enable_patch(patch);
		if (ret)
			goto err;
	} else {
		ret = __klp_disable_patch(patch);
		if (ret)
			goto err;
	}

	mutex_unlock(&klp_mutex);

	return count;

err:
	mutex_unlock(&klp_mutex);
	return ret;
}

static ssize_t enabled_show(struct kobject *kobj,
			    struct kobj_attribute *attr, char *buf)
{
	struct klp_patch *patch;

	patch = container_of(kobj, struct klp_patch, kobj);
516
	return snprintf(buf, PAGE_SIZE-1, "%d\n", patch->enabled);
517
518
}

519
520
521
522
523
524
525
526
static ssize_t transition_show(struct kobject *kobj,
			       struct kobj_attribute *attr, char *buf)
{
	struct klp_patch *patch;

	patch = container_of(kobj, struct klp_patch, kobj);
	return snprintf(buf, PAGE_SIZE-1, "%d\n",
			patch == klp_transition_patch);
527
528
}

529
530
531
532
533
534
535
536
537
538
539
static ssize_t signal_store(struct kobject *kobj, struct kobj_attribute *attr,
			    const char *buf, size_t count)
{
	struct klp_patch *patch;
	int ret;
	bool val;

	ret = kstrtobool(buf, &val);
	if (ret)
		return ret;

540
541
542
543
544
545
546
547
548
549
550
551
552
553
	if (!val)
		return count;

	mutex_lock(&klp_mutex);

	patch = container_of(kobj, struct klp_patch, kobj);
	if (patch != klp_transition_patch) {
		mutex_unlock(&klp_mutex);
		return -EINVAL;
	}

	klp_send_signals();

	mutex_unlock(&klp_mutex);
554
555
556
557

	return count;
}

558
559
560
561
562
563
564
565
566
567
568
static ssize_t force_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t count)
{
	struct klp_patch *patch;
	int ret;
	bool val;

	ret = kstrtobool(buf, &val);
	if (ret)
		return ret;

569
570
571
572
573
574
575
576
577
578
579
580
581
582
	if (!val)
		return count;

	mutex_lock(&klp_mutex);

	patch = container_of(kobj, struct klp_patch, kobj);
	if (patch != klp_transition_patch) {
		mutex_unlock(&klp_mutex);
		return -EINVAL;
	}

	klp_force_transition();

	mutex_unlock(&klp_mutex);
583
584
585
586

	return count;
}

587
static struct kobj_attribute enabled_kobj_attr = __ATTR_RW(enabled);
588
static struct kobj_attribute transition_kobj_attr = __ATTR_RO(transition);
589
static struct kobj_attribute signal_kobj_attr = __ATTR_WO(signal);
590
static struct kobj_attribute force_kobj_attr = __ATTR_WO(force);
591
592
static struct attribute *klp_patch_attrs[] = {
	&enabled_kobj_attr.attr,
593
	&transition_kobj_attr.attr,
594
	&signal_kobj_attr.attr,
595
	&force_kobj_attr.attr,
596
597
598
599
600
	NULL
};

static void klp_kobj_release_patch(struct kobject *kobj)
{
601
602
603
604
	struct klp_patch *patch;

	patch = container_of(kobj, struct klp_patch, kobj);
	complete(&patch->finish);
605
606
607
608
609
610
611
612
}

static struct kobj_type klp_ktype_patch = {
	.release = klp_kobj_release_patch,
	.sysfs_ops = &kobj_sysfs_ops,
	.default_attrs = klp_patch_attrs,
};

613
614
615
616
617
618
619
620
621
static void klp_kobj_release_object(struct kobject *kobj)
{
}

static struct kobj_type klp_ktype_object = {
	.release = klp_kobj_release_object,
	.sysfs_ops = &kobj_sysfs_ops,
};

622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
static void klp_kobj_release_func(struct kobject *kobj)
{
}

static struct kobj_type klp_ktype_func = {
	.release = klp_kobj_release_func,
	.sysfs_ops = &kobj_sysfs_ops,
};

/*
 * Free all functions' kobjects in the array up to some limit. When limit is
 * NULL, all kobjects are freed.
 */
static void klp_free_funcs_limited(struct klp_object *obj,
				   struct klp_func *limit)
{
	struct klp_func *func;

	for (func = obj->funcs; func->old_name && func != limit; func++)
		kobject_put(&func->kobj);
}

/* Clean up when a patched object is unloaded */
static void klp_free_object_loaded(struct klp_object *obj)
{
	struct klp_func *func;

	obj->mod = NULL;

651
	klp_for_each_func(obj, func)
652
653
654
655
656
657
658
659
660
661
662
663
664
665
		func->old_addr = 0;
}

/*
 * Free all objects' kobjects in the array up to some limit. When limit is
 * NULL, all kobjects are freed.
 */
static void klp_free_objects_limited(struct klp_patch *patch,
				     struct klp_object *limit)
{
	struct klp_object *obj;

	for (obj = patch->objs; obj->funcs && obj != limit; obj++) {
		klp_free_funcs_limited(obj, NULL);
666
		kobject_put(&obj->kobj);
667
668
669
670
671
672
673
674
675
676
677
678
	}
}

static void klp_free_patch(struct klp_patch *patch)
{
	klp_free_objects_limited(patch, NULL);
	if (!list_empty(&patch->list))
		list_del(&patch->list);
}

static int klp_init_func(struct klp_object *obj, struct klp_func *func)
{
679
680
681
	if (!func->old_name || !func->new_func)
		return -EINVAL;

682
683
684
	if (strlen(func->old_name) >= KSYM_NAME_LEN)
		return -EINVAL;

685
	INIT_LIST_HEAD(&func->stack_node);
686
	func->patched = false;
687
	func->transition = false;
688

689
690
691
692
693
	/* The format for the sysfs directory is <function,sympos> where sympos
	 * is the nth occurrence of this symbol in kallsyms for the patched
	 * object. If the user selects 0 for old_sympos, then 1 will be used
	 * since a unique symbol will be the first occurrence.
	 */
694
	return kobject_init_and_add(&func->kobj, &klp_ktype_func,
695
696
				    &obj->kobj, "%s,%lu", func->old_name,
				    func->old_sympos ? func->old_sympos : 1);
697
698
}

699
700
701
702
703
704
/* Arches may override this to finish any remaining arch-specific tasks */
void __weak arch_klp_init_object_loaded(struct klp_patch *patch,
					struct klp_object *obj)
{
}

705
706
707
708
709
710
711
/* parts of the initialization that is done only when the object is loaded */
static int klp_init_object_loaded(struct klp_patch *patch,
				  struct klp_object *obj)
{
	struct klp_func *func;
	int ret;

712
713
	mutex_lock(&text_mutex);

714
	module_disable_ro(patch->mod);
715
	ret = klp_write_object_relocations(patch->mod, obj);
716
717
	if (ret) {
		module_enable_ro(patch->mod, true);
718
		mutex_unlock(&text_mutex);
719
		return ret;
720
721
722
723
	}

	arch_klp_init_object_loaded(patch, obj);
	module_enable_ro(patch->mod, true);
724

725
726
	mutex_unlock(&text_mutex);

727
	klp_for_each_func(obj, func) {
728
729
730
		ret = klp_find_object_symbol(obj->name, func->old_name,
					     func->old_sympos,
					     &func->old_addr);
731
732
		if (ret)
			return ret;
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748

		ret = kallsyms_lookup_size_offset(func->old_addr,
						  &func->old_size, NULL);
		if (!ret) {
			pr_err("kallsyms size lookup failed for '%s'\n",
			       func->old_name);
			return -ENOENT;
		}

		ret = kallsyms_lookup_size_offset((unsigned long)func->new_func,
						  &func->new_size, NULL);
		if (!ret) {
			pr_err("kallsyms size lookup failed for '%s' replacement\n",
			       func->old_name);
			return -ENOENT;
		}
749
750
751
752
753
754
755
756
757
758
759
760
761
762
	}

	return 0;
}

static int klp_init_object(struct klp_patch *patch, struct klp_object *obj)
{
	struct klp_func *func;
	int ret;
	const char *name;

	if (!obj->funcs)
		return -EINVAL;

763
764
765
	if (klp_is_module(obj) && strlen(obj->name) >= MODULE_NAME_LEN)
		return -EINVAL;

766
	obj->patched = false;
767
	obj->mod = NULL;
768
769
770
771

	klp_find_object_module(obj);

	name = klp_is_module(obj) ? obj->name : "vmlinux";
772
773
774
775
	ret = kobject_init_and_add(&obj->kobj, &klp_ktype_object,
				   &patch->kobj, "%s", name);
	if (ret)
		return ret;
776

777
	klp_for_each_func(obj, func) {
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
		ret = klp_init_func(obj, func);
		if (ret)
			goto free;
	}

	if (klp_is_object_loaded(obj)) {
		ret = klp_init_object_loaded(patch, obj);
		if (ret)
			goto free;
	}

	return 0;

free:
	klp_free_funcs_limited(obj, func);
793
	kobject_put(&obj->kobj);
794
795
796
797
798
799
800
801
802
803
804
805
806
	return ret;
}

static int klp_init_patch(struct klp_patch *patch)
{
	struct klp_object *obj;
	int ret;

	if (!patch->objs)
		return -EINVAL;

	mutex_lock(&klp_mutex);

807
	patch->enabled = false;
808
	init_completion(&patch->finish);
809
810

	ret = kobject_init_and_add(&patch->kobj, &klp_ktype_patch,
811
				   klp_root_kobj, "%s", patch->mod->name);
812
813
814
815
	if (ret) {
		mutex_unlock(&klp_mutex);
		return ret;
	}
816

817
	klp_for_each_object(patch, obj) {
818
819
820
821
822
		ret = klp_init_object(patch, obj);
		if (ret)
			goto free;
	}

823
	list_add_tail(&patch->list, &klp_patches);
824
825
826
827
828
829
830

	mutex_unlock(&klp_mutex);

	return 0;

free:
	klp_free_objects_limited(patch, obj);
831

832
	mutex_unlock(&klp_mutex);
833
834
835
836

	kobject_put(&patch->kobj);
	wait_for_completion(&patch->finish);

837
838
839
840
841
842
843
844
845
846
847
848
849
	return ret;
}

/**
 * klp_unregister_patch() - unregisters a patch
 * @patch:	Disabled patch to be unregistered
 *
 * Frees the data structures and removes the sysfs interface.
 *
 * Return: 0 on success, otherwise error
 */
int klp_unregister_patch(struct klp_patch *patch)
{
850
	int ret;
851
852
853
854
855

	mutex_lock(&klp_mutex);

	if (!klp_is_patch_registered(patch)) {
		ret = -EINVAL;
856
		goto err;
857
858
	}

859
	if (patch->enabled) {
860
		ret = -EBUSY;
861
		goto err;
862
863
864
865
	}

	klp_free_patch(patch);

866
867
868
869
870
871
872
	mutex_unlock(&klp_mutex);

	kobject_put(&patch->kobj);
	wait_for_completion(&patch->finish);

	return 0;
err:
873
874
875
876
877
878
879
880
881
882
883
884
	mutex_unlock(&klp_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(klp_unregister_patch);

/**
 * klp_register_patch() - registers a patch
 * @patch:	Patch to be registered
 *
 * Initializes the data structure associated with the patch and
 * creates the sysfs interface.
 *
885
886
887
 * There is no need to take the reference on the patch module here. It is done
 * later when the patch is enabled.
 *
888
889
890
891
892
893
894
 * Return: 0 on success, otherwise error
 */
int klp_register_patch(struct klp_patch *patch)
{
	if (!patch || !patch->mod)
		return -EINVAL;

895
	if (!is_livepatch_module(patch->mod)) {
896
		pr_err("module %s is not marked as a livepatch module\n",
897
898
899
900
		       patch->mod->name);
		return -EINVAL;
	}

901
902
903
	if (!klp_initialized())
		return -ENODEV;

904
	if (!klp_have_reliable_stack()) {
905
906
907
		pr_err("This architecture doesn't have support for the livepatch consistency model.\n");
		return -ENOSYS;
	}
908

909
	return klp_init_patch(patch);
910
911
912
}
EXPORT_SYMBOL_GPL(klp_register_patch);

913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
/*
 * Remove parts of patches that touch a given kernel module. The list of
 * patches processed might be limited. When limit is NULL, all patches
 * will be handled.
 */
static void klp_cleanup_module_patches_limited(struct module *mod,
					       struct klp_patch *limit)
{
	struct klp_patch *patch;
	struct klp_object *obj;

	list_for_each_entry(patch, &klp_patches, list) {
		if (patch == limit)
			break;

		klp_for_each_object(patch, obj) {
			if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
				continue;

			/*
			 * Only unpatch the module if the patch is enabled or
			 * is in transition.
			 */
			if (patch->enabled || patch == klp_transition_patch) {
937
938
939
940

				if (patch != klp_transition_patch)
					klp_pre_unpatch_callback(obj);

941
942
943
				pr_notice("reverting patch '%s' on unloading module '%s'\n",
					  patch->mod->name, obj->mod->name);
				klp_unpatch_object(obj);
944
945

				klp_post_unpatch_callback(obj);
946
947
948
949
950
951
952
953
			}

			klp_free_object_loaded(obj);
			break;
		}
	}
}

954
int klp_module_coming(struct module *mod)
955
956
{
	int ret;
957
958
	struct klp_patch *patch;
	struct klp_object *obj;
959

960
961
	if (WARN_ON(mod->state != MODULE_STATE_COMING))
		return -EINVAL;
962

963
964
965
966
967
968
969
	mutex_lock(&klp_mutex);
	/*
	 * Each module has to know that klp_module_coming()
	 * has been called. We never know what module will
	 * get patched by a new patch.
	 */
	mod->klp_alive = true;
970

971
972
973
974
	list_for_each_entry(patch, &klp_patches, list) {
		klp_for_each_object(patch, obj) {
			if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
				continue;
975

976
			obj->mod = mod;
977

978
979
980
981
982
983
			ret = klp_init_object_loaded(patch, obj);
			if (ret) {
				pr_warn("failed to initialize patch '%s' for module '%s' (%d)\n",
					patch->mod->name, obj->mod->name, ret);
				goto err;
			}
984

985
986
987
988
989
			/*
			 * Only patch the module if the patch is enabled or is
			 * in transition.
			 */
			if (!patch->enabled && patch != klp_transition_patch)
990
991
992
993
994
				break;

			pr_notice("applying patch '%s' to loading module '%s'\n",
				  patch->mod->name, obj->mod->name);

995
996
997
998
999
1000
1001
			ret = klp_pre_patch_callback(obj);
			if (ret) {
				pr_warn("pre-patch callback failed for object '%s'\n",
					obj->name);
				goto err;
			}

1002
			ret = klp_patch_object(obj);
1003
1004
1005
			if (ret) {
				pr_warn("failed to apply patch '%s' to module '%s' (%d)\n",
					patch->mod->name, obj->mod->name, ret);
1006

1007
				klp_post_unpatch_callback(obj);
1008
1009
1010
				goto err;
			}

1011
1012
1013
			if (patch != klp_transition_patch)
				klp_post_patch_callback(obj);

1014
1015
1016
			break;
		}
	}
1017

1018
	mutex_unlock(&klp_mutex);
1019

1020
	return 0;
1021

1022
1023
1024
1025
1026
1027
1028
1029
err:
	/*
	 * If a patch is unsuccessfully applied, return
	 * error to the module loader.
	 */
	pr_warn("patch '%s' failed for module '%s', refusing to load module '%s'\n",
		patch->mod->name, obj->mod->name, obj->mod->name);
	mod->klp_alive = false;
1030
	obj->mod = NULL;
1031
	klp_cleanup_module_patches_limited(mod, patch);
1032
1033
1034
	mutex_unlock(&klp_mutex);

	return ret;
1035
1036
}

1037
void klp_module_going(struct module *mod)
1038
{
1039
1040
1041
	if (WARN_ON(mod->state != MODULE_STATE_GOING &&
		    mod->state != MODULE_STATE_COMING))
		return;
1042
1043

	mutex_lock(&klp_mutex);
1044
	/*
1045
1046
1047
	 * Each module has to know that klp_module_going()
	 * has been called. We never know what module will
	 * get patched by a new patch.
1048
	 */
1049
	mod->klp_alive = false;
1050

1051
	klp_cleanup_module_patches_limited(mod, NULL);
1052
1053
1054
1055

	mutex_unlock(&klp_mutex);
}

1056
static int __init klp_init(void)
1057
1058
1059
{
	int ret;

1060
1061
1062
1063
1064
1065
	ret = klp_check_compiler_support();
	if (ret) {
		pr_info("Your compiler is too old; turning off.\n");
		return -EINVAL;
	}

1066
	klp_root_kobj = kobject_create_and_add("livepatch", kernel_kobj);
1067
1068
	if (!klp_root_kobj)
		return -ENOMEM;
1069
1070
1071
1072
1073

	return 0;
}

module_init(klp_init);