change system file

hc

2024-10-09 244b2c5ca8b14627e4a17755e5922221e121c771

 kernel/kernel/livepatch/patch.c
..
..
@@ -1,22 +1,10 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * patch.c - livepatch patching functions
3
4
  *
4
5
  * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
5
6
  * Copyright (C) 2014 SUSE
6
7
  * Copyright (C) 2015 Josh Poimboeuf <jpoimboe@redhat.com>
7
- *
8
- * This program is free software; you can redistribute it and/or
9
- * modify it under the terms of the GNU General Public License
10
- * as published by the Free Software Foundation; either version 2
11
- * of the License, or (at your option) any later version.
12
- *
13
- * This program is distributed in the hope that it will be useful,
14
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
- * GNU General Public License for more details.
17
- *
18
- * You should have received a copy of the GNU General Public License
19
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
20
8
  */
21
9
 
22
10
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
..
..
@@ -34,7 +22,7 @@
34
22
 
35
23
 static LIST_HEAD(klp_ops);
36
24
 
37
-struct klp_ops *klp_find_ops(unsigned long old_addr)
25
+struct klp_ops *klp_find_ops(void *old_func)
38
26
 {
39
27
 	struct klp_ops *ops;
40
28
 	struct klp_func *func;
..
..
@@ -42,7 +30,7 @@
42
30
 	list_for_each_entry(ops, &klp_ops, node) {
43
31
 		func = list_first_entry(&ops->func_stack, struct klp_func,
44
32
 					stack_node);
45
-		if (func->old_addr == old_addr)
33
+		if (func->old_func == old_func)
46
34
 			return ops;
47
35
 	}
48
36
 
..
..
@@ -61,7 +49,7 @@
61
49
 	ops = container_of(fops, struct klp_ops, fops);
62
50
 
63
51
 	/*
64
-	 * A variant of synchronize_sched() is used to allow patching functions
52
+	 * A variant of synchronize_rcu() is used to allow patching functions
65
53
 	 * where RCU is not watching, see klp_synchronize_transition().
66
54
 	 */
67
55
 	preempt_disable_notrace();
..
..
@@ -72,7 +60,7 @@
72
60
 	/*
73
61
 	 * func should never be NULL because preemption should be disabled here
74
62
 	 * and unregister_ftrace_function() does the equivalent of a
75
-	 * synchronize_sched() before the func_stack removal.
63
+	 * synchronize_rcu() before the func_stack removal.
76
64
 	 */
77
65
 	if (WARN_ON_ONCE(!func))
78
66
 		goto unlock;
..
..
@@ -118,7 +106,15 @@
118
106
 		}
119
107
 	}
120
108
 
109
+	/*
110
+	 * NOPs are used to replace existing patches with original code.
111
+	 * Do nothing! Setting pc would cause an infinite loop.
112
+	 */
113
+	if (func->nop)
114
+		goto unlock;
115
+
121
116
 	klp_arch_set_pc(regs, (unsigned long)func->new_func);
117
+
122
118
 unlock:
123
119
 	preempt_enable_notrace();
124
120
 }
..
..
@@ -142,17 +138,18 @@
142
138
 
143
139
 	if (WARN_ON(!func->patched))
144
140
 		return;
145
-	if (WARN_ON(!func->old_addr))
141
+	if (WARN_ON(!func->old_func))
146
142
 		return;
147
143
 
148
-	ops = klp_find_ops(func->old_addr);
144
+	ops = klp_find_ops(func->old_func);
149
145
 	if (WARN_ON(!ops))
150
146
 		return;
151
147
 
152
148
 	if (list_is_singular(&ops->func_stack)) {
153
149
 		unsigned long ftrace_loc;
154
150
 
155
-		ftrace_loc = klp_get_ftrace_location(func->old_addr);
151
+		ftrace_loc =
152
+			klp_get_ftrace_location((unsigned long)func->old_func);
156
153
 		if (WARN_ON(!ftrace_loc))
157
154
 			return;
158
155
 
..
..
@@ -174,17 +171,18 @@
174
171
 	struct klp_ops *ops;
175
172
 	int ret;
176
173
 
177
-	if (WARN_ON(!func->old_addr))
174
+	if (WARN_ON(!func->old_func))
178
175
 		return -EINVAL;
179
176
 
180
177
 	if (WARN_ON(func->patched))
181
178
 		return -EINVAL;
182
179
 
183
-	ops = klp_find_ops(func->old_addr);
180
+	ops = klp_find_ops(func->old_func);
184
181
 	if (!ops) {
185
182
 		unsigned long ftrace_loc;
186
183
 
187
-		ftrace_loc = klp_get_ftrace_location(func->old_addr);
184
+		ftrace_loc =
185
+			klp_get_ftrace_location((unsigned long)func->old_func);
188
186
 		if (!ftrace_loc) {
189
187
 			pr_err("failed to find location for function '%s'\n",
190
188
 				func->old_name);
..
..
@@ -198,7 +196,8 @@
198
196
 		ops->fops.func = klp_ftrace_handler;
199
197
 		ops->fops.flags = FTRACE_OPS_FL_SAVE_REGS |
200
198
 				  FTRACE_OPS_FL_DYNAMIC |
201
-				  FTRACE_OPS_FL_IPMODIFY;
199
+				  FTRACE_OPS_FL_IPMODIFY |
200
+				  FTRACE_OPS_FL_PERMANENT;
202
201
 
203
202
 		list_add(&ops->node, &klp_ops);
204
203
 
..
..
@@ -236,15 +235,26 @@
236
235
 	return ret;
237
236
 }
238
237
 
239
-void klp_unpatch_object(struct klp_object *obj)
238
+static void __klp_unpatch_object(struct klp_object *obj, bool nops_only)
240
239
 {
241
240
 	struct klp_func *func;
242
241
 
243
-	klp_for_each_func(obj, func)
242
+	klp_for_each_func(obj, func) {
243
+		if (nops_only && !func->nop)
244
+			continue;
245
+
244
246
 		if (func->patched)
245
247
 			klp_unpatch_func(func);
248
+	}
246
249
 
247
-	obj->patched = false;
250
+	if (obj->dynamic || !nops_only)
251
+		obj->patched = false;
252
+}
253
+
254
+
255
+void klp_unpatch_object(struct klp_object *obj)
256
+{
257
+	__klp_unpatch_object(obj, false);
248
258
 }
249
259
 
250
260
 int klp_patch_object(struct klp_object *obj)
..
..
@@ -267,11 +277,21 @@
267
277
 	return 0;
268
278
 }
269
279
 
270
-void klp_unpatch_objects(struct klp_patch *patch)
280
+static void __klp_unpatch_objects(struct klp_patch *patch, bool nops_only)
271
281
 {
272
282
 	struct klp_object *obj;
273
283
 
274
284
 	klp_for_each_object(patch, obj)
275
285
 		if (obj->patched)
276
-			klp_unpatch_object(obj);
286
+			__klp_unpatch_object(obj, nops_only);
287
+}
288
+
289
+void klp_unpatch_objects(struct klp_patch *patch)
290
+{
291
+	__klp_unpatch_objects(patch, false);
292
+}
293
+
294
+void klp_unpatch_objects_dynamic(struct klp_patch *patch)
295
+{
296
+	__klp_unpatch_objects(patch, true);
277
297
 }