修改led为gpio

hc

2024-10-12 a5969cabbb4660eab42b6ef0412cbbd1200cf14d

 kernel/kernel/trace/trace_irqsoff.c
..
..
@@ -143,14 +143,11 @@
143
143
 	struct trace_array *tr = irqsoff_trace;
144
144
 	struct trace_array_cpu *data;
145
145
 	unsigned long flags;
146
-	unsigned int trace_ctx;
147
146
 
148
147
 	if (!func_prolog_dec(tr, &data, &flags))
149
148
 		return;
150
149
 
151
-	trace_ctx = tracing_gen_ctx_flags(flags);
152
-
153
-	trace_function(tr, ip, parent_ip, trace_ctx);
150
+	trace_function(tr, ip, parent_ip, flags, preempt_count());
154
151
 
155
152
 	atomic_dec(&data->disabled);
156
153
 }
..
..
@@ -180,8 +177,8 @@
180
177
 	struct trace_array *tr = irqsoff_trace;
181
178
 	struct trace_array_cpu *data;
182
179
 	unsigned long flags;
183
-	unsigned int trace_ctx;
184
180
 	int ret;
181
+	int pc;
185
182
 
186
183
 	if (ftrace_graph_ignore_func(trace))
187
184
 		return 0;
..
..
@@ -198,8 +195,8 @@
198
195
 	if (!func_prolog_dec(tr, &data, &flags))
199
196
 		return 0;
200
197
 
201
-	trace_ctx = tracing_gen_ctx_flags(flags);
202
-	ret = __trace_graph_entry(tr, trace, trace_ctx);
198
+	pc = preempt_count();
199
+	ret = __trace_graph_entry(tr, trace, flags, pc);
203
200
 	atomic_dec(&data->disabled);
204
201
 
205
202
 	return ret;
..
..
@@ -210,15 +207,15 @@
210
207
 	struct trace_array *tr = irqsoff_trace;
211
208
 	struct trace_array_cpu *data;
212
209
 	unsigned long flags;
213
-	unsigned int trace_ctx;
210
+	int pc;
214
211
 
215
212
 	ftrace_graph_addr_finish(trace);
216
213
 
217
214
 	if (!func_prolog_dec(tr, &data, &flags))
218
215
 		return;
219
216
 
220
-	trace_ctx = tracing_gen_ctx_flags(flags);
221
-	__trace_graph_return(tr, trace, trace_ctx);
217
+	pc = preempt_count();
218
+	__trace_graph_return(tr, trace, flags, pc);
222
219
 	atomic_dec(&data->disabled);
223
220
 }
224
221
 
..
..
@@ -231,7 +228,8 @@
231
228
 {
232
229
 	if (is_graph(iter->tr))
233
230
 		graph_trace_open(iter);
234
-
231
+	else
232
+		iter->private = NULL;
235
233
 }
236
234
 
237
235
 static void irqsoff_trace_close(struct trace_iterator *iter)
..
..
@@ -270,12 +268,12 @@
270
268
 static void
271
269
 __trace_function(struct trace_array *tr,
272
270
 		 unsigned long ip, unsigned long parent_ip,
273
-		 unsigned int trace_ctx)
271
+		 unsigned long flags, int pc)
274
272
 {
275
273
 	if (is_graph(tr))
276
-		trace_graph_function(tr, ip, parent_ip, trace_ctx);
274
+		trace_graph_function(tr, ip, parent_ip, flags, pc);
277
275
 	else
278
-		trace_function(tr, ip, parent_ip, trace_ctx);
276
+		trace_function(tr, ip, parent_ip, flags, pc);
279
277
 }
280
278
 
281
279
 #else
..
..
@@ -325,13 +323,15 @@
325
323
 {
326
324
 	u64 T0, T1, delta;
327
325
 	unsigned long flags;
328
-	unsigned int trace_ctx;
326
+	int pc;
329
327
 
330
328
 	T0 = data->preempt_timestamp;
331
329
 	T1 = ftrace_now(cpu);
332
330
 	delta = T1-T0;
333
331
 
334
-	trace_ctx = tracing_gen_ctx();
332
+	local_save_flags(flags);
333
+
334
+	pc = preempt_count();
335
335
 
336
336
 	if (!report_latency(tr, delta))
337
337
 		goto out;
..
..
@@ -342,9 +342,9 @@
342
342
 	if (!report_latency(tr, delta))
343
343
 		goto out_unlock;
344
344
 
345
-	__trace_function(tr, CALLER_ADDR0, parent_ip, trace_ctx);
345
+	__trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
346
346
 	/* Skip 5 functions to get to the irq/preempt enable function */
347
-	__trace_stack(tr, trace_ctx, 5);
347
+	__trace_stack(tr, flags, 5, pc);
348
348
 
349
349
 	if (data->critical_sequence != max_sequence)
350
350
 		goto out_unlock;
..
..
@@ -364,15 +364,16 @@
364
364
 out:
365
365
 	data->critical_sequence = max_sequence;
366
366
 	data->preempt_timestamp = ftrace_now(cpu);
367
-	__trace_function(tr, CALLER_ADDR0, parent_ip, trace_ctx);
367
+	__trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
368
368
 }
369
369
 
370
370
 static nokprobe_inline void
371
-start_critical_timing(unsigned long ip, unsigned long parent_ip)
371
+start_critical_timing(unsigned long ip, unsigned long parent_ip, int pc)
372
372
 {
373
373
 	int cpu;
374
374
 	struct trace_array *tr = irqsoff_trace;
375
375
 	struct trace_array_cpu *data;
376
+	unsigned long flags;
376
377
 
377
378
 	if (!tracer_enabled || !tracing_is_enabled())
378
379
 		return;
..
..
@@ -393,7 +394,9 @@
393
394
 	data->preempt_timestamp = ftrace_now(cpu);
394
395
 	data->critical_start = parent_ip ? : ip;
395
396
 
396
-	__trace_function(tr, ip, parent_ip, tracing_gen_ctx());
397
+	local_save_flags(flags);
398
+
399
+	__trace_function(tr, ip, parent_ip, flags, pc);
397
400
 
398
401
 	per_cpu(tracing_cpu, cpu) = 1;
399
402
 
..
..
@@ -401,12 +404,12 @@
401
404
 }
402
405
 
403
406
 static nokprobe_inline void
404
-stop_critical_timing(unsigned long ip, unsigned long parent_ip)
407
+stop_critical_timing(unsigned long ip, unsigned long parent_ip, int pc)
405
408
 {
406
409
 	int cpu;
407
410
 	struct trace_array *tr = irqsoff_trace;
408
411
 	struct trace_array_cpu *data;
409
-	unsigned int trace_ctx;
412
+	unsigned long flags;
410
413
 
411
414
 	cpu = raw_smp_processor_id();
412
415
 	/* Always clear the tracing cpu on stopping the trace */
..
..
@@ -426,8 +429,8 @@
426
429
 
427
430
 	atomic_inc(&data->disabled);
428
431
 
429
-	trace_ctx = tracing_gen_ctx();
430
-	__trace_function(tr, ip, parent_ip, trace_ctx);
432
+	local_save_flags(flags);
433
+	__trace_function(tr, ip, parent_ip, flags, pc);
431
434
 	check_critical_timing(tr, data, parent_ip ? : ip, cpu);
432
435
 	data->critical_start = 0;
433
436
 	atomic_dec(&data->disabled);
..
..
@@ -436,16 +439,20 @@
436
439
 /* start and stop critical timings used to for stoppage (in idle) */
437
440
 void start_critical_timings(void)
438
441
 {
439
-	if (preempt_trace(preempt_count()) || irq_trace())
440
-		start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
442
+	int pc = preempt_count();
443
+
444
+	if (preempt_trace(pc) || irq_trace())
445
+		start_critical_timing(CALLER_ADDR0, CALLER_ADDR1, pc);
441
446
 }
442
447
 EXPORT_SYMBOL_GPL(start_critical_timings);
443
448
 NOKPROBE_SYMBOL(start_critical_timings);
444
449
 
445
450
 void stop_critical_timings(void)
446
451
 {
447
-	if (preempt_trace(preempt_count()) || irq_trace())
448
-		stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
452
+	int pc = preempt_count();
453
+
454
+	if (preempt_trace(pc) || irq_trace())
455
+		stop_critical_timing(CALLER_ADDR0, CALLER_ADDR1, pc);
449
456
 }
450
457
 EXPORT_SYMBOL_GPL(stop_critical_timings);
451
458
 NOKPROBE_SYMBOL(stop_critical_timings);
..
..
@@ -607,15 +614,19 @@
607
614
  */
608
615
 void tracer_hardirqs_on(unsigned long a0, unsigned long a1)
609
616
 {
610
-	if (!preempt_trace(preempt_count()) && irq_trace())
611
-		stop_critical_timing(a0, a1);
617
+	unsigned int pc = preempt_count();
618
+
619
+	if (!preempt_trace(pc) && irq_trace())
620
+		stop_critical_timing(a0, a1, pc);
612
621
 }
613
622
 NOKPROBE_SYMBOL(tracer_hardirqs_on);
614
623
 
615
624
 void tracer_hardirqs_off(unsigned long a0, unsigned long a1)
616
625
 {
617
-	if (!preempt_trace(preempt_count()) && irq_trace())
618
-		start_critical_timing(a0, a1);
626
+	unsigned int pc = preempt_count();
627
+
628
+	if (!preempt_trace(pc) && irq_trace())
629
+		start_critical_timing(a0, a1, pc);
619
630
 }
620
631
 NOKPROBE_SYMBOL(tracer_hardirqs_off);
621
632
 
..
..
@@ -655,14 +666,18 @@
655
666
 #ifdef CONFIG_PREEMPT_TRACER
656
667
 void tracer_preempt_on(unsigned long a0, unsigned long a1)
657
668
 {
658
-	if (preempt_trace(preempt_count()) && !irq_trace())
659
-		stop_critical_timing(a0, a1);
669
+	int pc = preempt_count();
670
+
671
+	if (preempt_trace(pc) && !irq_trace())
672
+		stop_critical_timing(a0, a1, pc);
660
673
 }
661
674
 
662
675
 void tracer_preempt_off(unsigned long a0, unsigned long a1)
663
676
 {
664
-	if (preempt_trace(preempt_count()) && !irq_trace())
665
-		start_critical_timing(a0, a1);
677
+	int pc = preempt_count();
678
+
679
+	if (preempt_trace(pc) && !irq_trace())
680
+		start_critical_timing(a0, a1, pc);
666
681
 }
667
682
 
668
683
 static int preemptoff_tracer_init(struct trace_array *tr)