xref: /linux/include/rv/da_monitor.h (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (C) 2019-2022 Red Hat, Inc. Daniel Bristot de Oliveira <bristot@kernel.org>
4  *
5  * Deterministic automata (DA) monitor functions, to be used together
6  * with automata models in C generated by the dot2k tool.
7  *
8  * The dot2k tool is available at tools/verification/dot2k/
9  *
10  * For further information, see:
11  *   Documentation/trace/rv/da_monitor_synthesis.rst
12  */
13 
14 #include <rv/automata.h>
15 #include <linux/rv.h>
16 #include <linux/bug.h>
17 
18 #ifdef CONFIG_RV_REACTORS
19 
20 #define DECLARE_RV_REACTING_HELPERS(name, type)							\
21 static char REACT_MSG_##name[1024];								\
22 												\
23 static inline char *format_react_msg_##name(type curr_state, type event)			\
24 {												\
25 	snprintf(REACT_MSG_##name, 1024,							\
26 		 "rv: monitor %s does not allow event %s on state %s\n",			\
27 		 #name,										\
28 		 model_get_event_name_##name(event),						\
29 		 model_get_state_name_##name(curr_state));					\
30 	return REACT_MSG_##name;								\
31 }												\
32 												\
33 static void cond_react_##name(char *msg)							\
34 {												\
35 	if (rv_##name.react)									\
36 		rv_##name.react(msg);								\
37 }												\
38 												\
39 static bool rv_reacting_on_##name(void)								\
40 {												\
41 	return rv_reacting_on();								\
42 }
43 
44 #else /* CONFIG_RV_REACTOR */
45 
46 #define DECLARE_RV_REACTING_HELPERS(name, type)							\
47 static inline char *format_react_msg_##name(type curr_state, type event)			\
48 {												\
49 	return NULL;										\
50 }												\
51 												\
52 static void cond_react_##name(char *msg)							\
53 {												\
54 	return;											\
55 }												\
56 												\
57 static bool rv_reacting_on_##name(void)								\
58 {												\
59 	return 0;										\
60 }
61 #endif
62 
63 /*
64  * Generic helpers for all types of deterministic automata monitors.
65  */
66 #define DECLARE_DA_MON_GENERIC_HELPERS(name, type)						\
67 												\
68 DECLARE_RV_REACTING_HELPERS(name, type)								\
69 												\
70 /*												\
71  * da_monitor_reset_##name - reset a monitor and setting it to init state			\
72  */												\
73 static inline void da_monitor_reset_##name(struct da_monitor *da_mon)				\
74 {												\
75 	da_mon->monitoring = 0;									\
76 	da_mon->curr_state = model_get_initial_state_##name();					\
77 }												\
78 												\
79 /*												\
80  * da_monitor_curr_state_##name - return the current state					\
81  */												\
82 static inline type da_monitor_curr_state_##name(struct da_monitor *da_mon)			\
83 {												\
84 	return da_mon->curr_state;								\
85 }												\
86 												\
87 /*												\
88  * da_monitor_set_state_##name - set the new current state					\
89  */												\
90 static inline void										\
91 da_monitor_set_state_##name(struct da_monitor *da_mon, enum states_##name state)		\
92 {												\
93 	da_mon->curr_state = state;								\
94 }												\
95 												\
96 /*												\
97  * da_monitor_start_##name - start monitoring							\
98  *												\
99  * The monitor will ignore all events until monitoring is set to true. This			\
100  * function needs to be called to tell the monitor to start monitoring.				\
101  */												\
102 static inline void da_monitor_start_##name(struct da_monitor *da_mon)				\
103 {												\
104 	da_mon->curr_state = model_get_initial_state_##name();					\
105 	da_mon->monitoring = 1;									\
106 }												\
107 												\
108 /*												\
109  * da_monitoring_##name - returns true if the monitor is processing events			\
110  */												\
111 static inline bool da_monitoring_##name(struct da_monitor *da_mon)				\
112 {												\
113 	return da_mon->monitoring;								\
114 }												\
115 												\
116 /*												\
117  * da_monitor_enabled_##name - checks if the monitor is enabled					\
118  */												\
119 static inline bool da_monitor_enabled_##name(void)						\
120 {												\
121 	/* global switch */									\
122 	if (unlikely(!rv_monitoring_on()))							\
123 		return 0;									\
124 												\
125 	/* monitor enabled */									\
126 	if (unlikely(!rv_##name.enabled))							\
127 		return 0;									\
128 												\
129 	return 1;										\
130 }												\
131 												\
132 /*												\
133  * da_monitor_handling_event_##name - checks if the monitor is ready to handle events		\
134  */												\
135 static inline bool da_monitor_handling_event_##name(struct da_monitor *da_mon)			\
136 {												\
137 												\
138 	if (!da_monitor_enabled_##name())							\
139 		return 0;									\
140 												\
141 	/* monitor is actually monitoring */							\
142 	if (unlikely(!da_monitoring_##name(da_mon)))						\
143 		return 0;									\
144 												\
145 	return 1;										\
146 }
147 
148 /*
149  * Event handler for implicit monitors. Implicit monitor is the one which the
150  * handler does not need to specify which da_monitor to manipulate. Examples
151  * of implicit monitor are the per_cpu or the global ones.
152  */
153 #define DECLARE_DA_MON_MODEL_HANDLER_IMPLICIT(name, type)					\
154 												\
155 static inline bool										\
156 da_event_##name(struct da_monitor *da_mon, enum events_##name event)				\
157 {												\
158 	type curr_state = da_monitor_curr_state_##name(da_mon);					\
159 	type next_state = model_get_next_state_##name(curr_state, event);			\
160 												\
161 	if (next_state != INVALID_STATE) {							\
162 		da_monitor_set_state_##name(da_mon, next_state);				\
163 												\
164 		trace_event_##name(model_get_state_name_##name(curr_state),			\
165 				   model_get_event_name_##name(event),				\
166 				   model_get_state_name_##name(next_state),			\
167 				   model_is_final_state_##name(next_state));			\
168 												\
169 		return true;									\
170 	}											\
171 												\
172 	if (rv_reacting_on_##name())								\
173 		cond_react_##name(format_react_msg_##name(curr_state, event));			\
174 												\
175 	trace_error_##name(model_get_state_name_##name(curr_state),				\
176 			   model_get_event_name_##name(event));					\
177 												\
178 	return false;										\
179 }												\
180 
181 /*
182  * Event handler for per_task monitors.
183  */
184 #define DECLARE_DA_MON_MODEL_HANDLER_PER_TASK(name, type)					\
185 												\
186 static inline bool da_event_##name(struct da_monitor *da_mon, struct task_struct *tsk,		\
187 				   enum events_##name event)					\
188 {												\
189 	type curr_state = da_monitor_curr_state_##name(da_mon);					\
190 	type next_state = model_get_next_state_##name(curr_state, event);			\
191 												\
192 	if (next_state != INVALID_STATE) {							\
193 		da_monitor_set_state_##name(da_mon, next_state);				\
194 												\
195 		trace_event_##name(tsk->pid,							\
196 				   model_get_state_name_##name(curr_state),			\
197 				   model_get_event_name_##name(event),				\
198 				   model_get_state_name_##name(next_state),			\
199 				   model_is_final_state_##name(next_state));			\
200 												\
201 		return true;									\
202 	}											\
203 												\
204 	if (rv_reacting_on_##name())								\
205 		cond_react_##name(format_react_msg_##name(curr_state, event));			\
206 												\
207 	trace_error_##name(tsk->pid,								\
208 			   model_get_state_name_##name(curr_state),				\
209 			   model_get_event_name_##name(event));					\
210 												\
211 	return false;										\
212 }
213 
214 /*
215  * Functions to define, init and get a global monitor.
216  */
217 #define DECLARE_DA_MON_INIT_GLOBAL(name, type)							\
218 												\
219 /*												\
220  * global monitor (a single variable)								\
221  */												\
222 static struct da_monitor da_mon_##name;								\
223 												\
224 /*												\
225  * da_get_monitor_##name - return the global monitor address					\
226  */												\
227 static struct da_monitor *da_get_monitor_##name(void)						\
228 {												\
229 	return &da_mon_##name;									\
230 }												\
231 												\
232 /*												\
233  * da_monitor_reset_all_##name - reset the single monitor					\
234  */												\
235 static void da_monitor_reset_all_##name(void)							\
236 {												\
237 	da_monitor_reset_##name(da_get_monitor_##name());					\
238 }												\
239 												\
240 /*												\
241  * da_monitor_init_##name - initialize a monitor						\
242  */												\
243 static inline int da_monitor_init_##name(void)							\
244 {												\
245 	da_monitor_reset_all_##name();								\
246 	return 0;										\
247 }												\
248 												\
249 /*												\
250  * da_monitor_destroy_##name - destroy the monitor						\
251  */												\
252 static inline void da_monitor_destroy_##name(void)						\
253 {												\
254 	return;											\
255 }
256 
257 /*
258  * Functions to define, init and get a per-cpu monitor.
259  */
260 #define DECLARE_DA_MON_INIT_PER_CPU(name, type)							\
261 												\
262 /*												\
263  * per-cpu monitor variables									\
264  */												\
265 static DEFINE_PER_CPU(struct da_monitor, da_mon_##name);					\
266 												\
267 /*												\
268  * da_get_monitor_##name - return current CPU monitor address					\
269  */												\
270 static struct da_monitor *da_get_monitor_##name(void)						\
271 {												\
272 	return this_cpu_ptr(&da_mon_##name);							\
273 }												\
274 												\
275 /*												\
276  * da_monitor_reset_all_##name - reset all CPUs' monitor					\
277  */												\
278 static void da_monitor_reset_all_##name(void)							\
279 {												\
280 	struct da_monitor *da_mon;								\
281 	int cpu;										\
282 	for_each_cpu(cpu, cpu_online_mask) {							\
283 		da_mon = per_cpu_ptr(&da_mon_##name, cpu);					\
284 		da_monitor_reset_##name(da_mon);						\
285 	}											\
286 }												\
287 												\
288 /*												\
289  * da_monitor_init_##name - initialize all CPUs' monitor					\
290  */												\
291 static inline int da_monitor_init_##name(void)							\
292 {												\
293 	da_monitor_reset_all_##name();								\
294 	return 0;										\
295 }												\
296 												\
297 /*												\
298  * da_monitor_destroy_##name - destroy the monitor						\
299  */												\
300 static inline void da_monitor_destroy_##name(void)						\
301 {												\
302 	return;											\
303 }
304 
305 /*
306  * Functions to define, init and get a per-task monitor.
307  */
308 #define DECLARE_DA_MON_INIT_PER_TASK(name, type)						\
309 												\
310 /*												\
311  * The per-task monitor is stored a vector in the task struct. This variable			\
312  * stores the position on the vector reserved for this monitor.					\
313  */												\
314 static int task_mon_slot_##name = RV_PER_TASK_MONITOR_INIT;					\
315 												\
316 /*												\
317  * da_get_monitor_##name - return the monitor in the allocated slot for tsk 			\
318  */												\
319 static inline struct da_monitor *da_get_monitor_##name(struct task_struct *tsk)			\
320 {												\
321 	return &tsk->rv[task_mon_slot_##name].da_mon;						\
322 }												\
323 												\
324 static void da_monitor_reset_all_##name(void)							\
325 {												\
326 	struct task_struct *g, *p;								\
327 												\
328 	read_lock(&tasklist_lock);								\
329 	for_each_process_thread(g, p)								\
330 		da_monitor_reset_##name(da_get_monitor_##name(p));				\
331 	read_unlock(&tasklist_lock);								\
332 }												\
333 												\
334 /*												\
335  * da_monitor_init_##name - initialize the per-task monitor					\
336  *												\
337  * Try to allocate a slot in the task's vector of monitors. If there				\
338  * is an available slot, use it and reset all task's monitor.					\
339  */												\
340 static int da_monitor_init_##name(void)								\
341 {												\
342 	int slot;										\
343 												\
344 	slot = rv_get_task_monitor_slot();							\
345 	if (slot < 0 || slot >= RV_PER_TASK_MONITOR_INIT)					\
346 		return slot;									\
347 												\
348 	task_mon_slot_##name = slot;								\
349 												\
350 	da_monitor_reset_all_##name();								\
351 	return 0;										\
352 }												\
353 												\
354 /*												\
355  * da_monitor_destroy_##name - return the allocated slot					\
356  */												\
357 static inline void da_monitor_destroy_##name(void)						\
358 {												\
359 	if (task_mon_slot_##name == RV_PER_TASK_MONITOR_INIT) {					\
360 		WARN_ONCE(1, "Disabling a disabled monitor: " #name);				\
361 		return;										\
362 	}											\
363 	rv_put_task_monitor_slot(task_mon_slot_##name);						\
364 	task_mon_slot_##name = RV_PER_TASK_MONITOR_INIT;					\
365 	return;											\
366 }
367 
368 /*
369  * Handle event for implicit monitor: da_get_monitor_##name() will figure out
370  * the monitor.
371  */
372 #define DECLARE_DA_MON_MONITOR_HANDLER_IMPLICIT(name, type)					\
373 												\
374 static inline void __da_handle_event_##name(struct da_monitor *da_mon,				\
375 					    enum events_##name event)				\
376 {												\
377 	bool retval;										\
378 												\
379 	retval = da_event_##name(da_mon, event);						\
380 	if (!retval)										\
381 		da_monitor_reset_##name(da_mon);						\
382 }												\
383 												\
384 /*												\
385  * da_handle_event_##name - handle an event							\
386  */												\
387 static inline void da_handle_event_##name(enum events_##name event)				\
388 {												\
389 	struct da_monitor *da_mon = da_get_monitor_##name();					\
390 	bool retval;										\
391 												\
392 	retval = da_monitor_handling_event_##name(da_mon);					\
393 	if (!retval)										\
394 		return;										\
395 												\
396 	__da_handle_event_##name(da_mon, event);						\
397 }												\
398 												\
399 /*												\
400  * da_handle_start_event_##name - start monitoring or handle event				\
401  *												\
402  * This function is used to notify the monitor that the system is returning			\
403  * to the initial state, so the monitor can start monitoring in the next event.			\
404  * Thus:											\
405  *												\
406  * If the monitor already started, handle the event.						\
407  * If the monitor did not start yet, start the monitor but skip the event.			\
408  */												\
409 static inline bool da_handle_start_event_##name(enum events_##name event)			\
410 {												\
411 	struct da_monitor *da_mon;								\
412 												\
413 	if (!da_monitor_enabled_##name())							\
414 		return 0;									\
415 												\
416 	da_mon = da_get_monitor_##name();							\
417 												\
418 	if (unlikely(!da_monitoring_##name(da_mon))) {						\
419 		da_monitor_start_##name(da_mon);						\
420 		return 0;									\
421 	}											\
422 												\
423 	__da_handle_event_##name(da_mon, event);						\
424 												\
425 	return 1;										\
426 }												\
427 												\
428 /*												\
429  * da_handle_start_run_event_##name - start monitoring and handle event				\
430  *												\
431  * This function is used to notify the monitor that the system is in the			\
432  * initial state, so the monitor can start monitoring and handling event.			\
433  */												\
434 static inline bool da_handle_start_run_event_##name(enum events_##name event)			\
435 {												\
436 	struct da_monitor *da_mon;								\
437 												\
438 	if (!da_monitor_enabled_##name())							\
439 		return 0;									\
440 												\
441 	da_mon = da_get_monitor_##name();							\
442 												\
443 	if (unlikely(!da_monitoring_##name(da_mon)))						\
444 		da_monitor_start_##name(da_mon);						\
445 												\
446 	__da_handle_event_##name(da_mon, event);						\
447 												\
448 	return 1;										\
449 }
450 
451 /*
452  * Handle event for per task.
453  */
454 #define DECLARE_DA_MON_MONITOR_HANDLER_PER_TASK(name, type)					\
455 												\
456 static inline void										\
457 __da_handle_event_##name(struct da_monitor *da_mon, struct task_struct *tsk,			\
458 			 enum events_##name event)						\
459 {												\
460 	bool retval;										\
461 												\
462 	retval = da_event_##name(da_mon, tsk, event);						\
463 	if (!retval)										\
464 		da_monitor_reset_##name(da_mon);						\
465 }												\
466 												\
467 /*												\
468  * da_handle_event_##name - handle an event							\
469  */												\
470 static inline void										\
471 da_handle_event_##name(struct task_struct *tsk, enum events_##name event)			\
472 {												\
473 	struct da_monitor *da_mon = da_get_monitor_##name(tsk);					\
474 	bool retval;										\
475 												\
476 	retval = da_monitor_handling_event_##name(da_mon);					\
477 	if (!retval)										\
478 		return;										\
479 												\
480 	__da_handle_event_##name(da_mon, tsk, event);						\
481 }												\
482 												\
483 /*												\
484  * da_handle_start_event_##name - start monitoring or handle event				\
485  *												\
486  * This function is used to notify the monitor that the system is returning			\
487  * to the initial state, so the monitor can start monitoring in the next event.			\
488  * Thus:											\
489  *												\
490  * If the monitor already started, handle the event.						\
491  * If the monitor did not start yet, start the monitor but skip the event.			\
492  */												\
493 static inline bool										\
494 da_handle_start_event_##name(struct task_struct *tsk, enum events_##name event)			\
495 {												\
496 	struct da_monitor *da_mon;								\
497 												\
498 	if (!da_monitor_enabled_##name())							\
499 		return 0;									\
500 												\
501 	da_mon = da_get_monitor_##name(tsk);							\
502 												\
503 	if (unlikely(!da_monitoring_##name(da_mon))) {						\
504 		da_monitor_start_##name(da_mon);						\
505 		return 0;									\
506 	}											\
507 												\
508 	__da_handle_event_##name(da_mon, tsk, event);						\
509 												\
510 	return 1;										\
511 }
512 
513 /*
514  * Entry point for the global monitor.
515  */
516 #define DECLARE_DA_MON_GLOBAL(name, type)							\
517 												\
518 DECLARE_AUTOMATA_HELPERS(name, type)								\
519 DECLARE_DA_MON_GENERIC_HELPERS(name, type)							\
520 DECLARE_DA_MON_MODEL_HANDLER_IMPLICIT(name, type)						\
521 DECLARE_DA_MON_INIT_GLOBAL(name, type)								\
522 DECLARE_DA_MON_MONITOR_HANDLER_IMPLICIT(name, type)
523 
524 /*
525  * Entry point for the per-cpu monitor.
526  */
527 #define DECLARE_DA_MON_PER_CPU(name, type)							\
528 												\
529 DECLARE_AUTOMATA_HELPERS(name, type)								\
530 DECLARE_DA_MON_GENERIC_HELPERS(name, type)							\
531 DECLARE_DA_MON_MODEL_HANDLER_IMPLICIT(name, type)						\
532 DECLARE_DA_MON_INIT_PER_CPU(name, type)								\
533 DECLARE_DA_MON_MONITOR_HANDLER_IMPLICIT(name, type)
534 
535 /*
536  * Entry point for the per-task monitor.
537  */
538 #define DECLARE_DA_MON_PER_TASK(name, type)							\
539 												\
540 DECLARE_AUTOMATA_HELPERS(name, type)								\
541 DECLARE_DA_MON_GENERIC_HELPERS(name, type)							\
542 DECLARE_DA_MON_MODEL_HANDLER_PER_TASK(name, type)						\
543 DECLARE_DA_MON_INIT_PER_TASK(name, type)							\
544 DECLARE_DA_MON_MONITOR_HANDLER_PER_TASK(name, type)
545