1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Generic Counter character device interface
4  * Copyright (C) 2020 William Breathitt Gray
5  */
6 #include <linux/cdev.h>
7 #include <linux/counter.h>
8 #include <linux/err.h>
9 #include <linux/errno.h>
10 #include <linux/export.h>
11 #include <linux/fs.h>
12 #include <linux/kfifo.h>
13 #include <linux/list.h>
14 #include <linux/mutex.h>
15 #include <linux/nospec.h>
16 #include <linux/poll.h>
17 #include <linux/slab.h>
18 #include <linux/spinlock.h>
19 #include <linux/timekeeping.h>
20 #include <linux/types.h>
21 #include <linux/uaccess.h>
22 #include <linux/wait.h>
23 
24 #include "counter-chrdev.h"
25 
26 struct counter_comp_node {
27 	struct list_head l;
28 	struct counter_component component;
29 	struct counter_comp comp;
30 	void *parent;
31 };
32 
33 #define counter_comp_read_is_equal(a, b) \
34 	(a.action_read == b.action_read || \
35 	a.device_u8_read == b.device_u8_read || \
36 	a.count_u8_read == b.count_u8_read || \
37 	a.signal_u8_read == b.signal_u8_read || \
38 	a.device_u32_read == b.device_u32_read || \
39 	a.count_u32_read == b.count_u32_read || \
40 	a.signal_u32_read == b.signal_u32_read || \
41 	a.device_u64_read == b.device_u64_read || \
42 	a.count_u64_read == b.count_u64_read || \
43 	a.signal_u64_read == b.signal_u64_read)
44 
45 #define counter_comp_read_is_set(comp) \
46 	(comp.action_read || \
47 	comp.device_u8_read || \
48 	comp.count_u8_read || \
49 	comp.signal_u8_read || \
50 	comp.device_u32_read || \
51 	comp.count_u32_read || \
52 	comp.signal_u32_read || \
53 	comp.device_u64_read || \
54 	comp.count_u64_read || \
55 	comp.signal_u64_read)
56 
57 static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
58 				   size_t len, loff_t *f_ps)
59 {
60 	struct counter_device *const counter = filp->private_data;
61 	int err;
62 	unsigned int copied;
63 
64 	if (!counter->ops)
65 		return -ENODEV;
66 
67 	if (len < sizeof(struct counter_event))
68 		return -EINVAL;
69 
70 	do {
71 		if (kfifo_is_empty(&counter->events)) {
72 			if (filp->f_flags & O_NONBLOCK)
73 				return -EAGAIN;
74 
75 			err = wait_event_interruptible(counter->events_wait,
76 					!kfifo_is_empty(&counter->events) ||
77 					!counter->ops);
78 			if (err < 0)
79 				return err;
80 			if (!counter->ops)
81 				return -ENODEV;
82 		}
83 
84 		if (mutex_lock_interruptible(&counter->events_out_lock))
85 			return -ERESTARTSYS;
86 		err = kfifo_to_user(&counter->events, buf, len, &copied);
87 		mutex_unlock(&counter->events_out_lock);
88 		if (err < 0)
89 			return err;
90 	} while (!copied);
91 
92 	return copied;
93 }
94 
95 static __poll_t counter_chrdev_poll(struct file *filp,
96 				    struct poll_table_struct *pollt)
97 {
98 	struct counter_device *const counter = filp->private_data;
99 	__poll_t events = 0;
100 
101 	if (!counter->ops)
102 		return events;
103 
104 	poll_wait(filp, &counter->events_wait, pollt);
105 
106 	if (!kfifo_is_empty(&counter->events))
107 		events = EPOLLIN | EPOLLRDNORM;
108 
109 	return events;
110 }
111 
112 static void counter_events_list_free(struct list_head *const events_list)
113 {
114 	struct counter_event_node *p, *n;
115 	struct counter_comp_node *q, *o;
116 
117 	list_for_each_entry_safe(p, n, events_list, l) {
118 		/* Free associated component nodes */
119 		list_for_each_entry_safe(q, o, &p->comp_list, l) {
120 			list_del(&q->l);
121 			kfree(q);
122 		}
123 
124 		/* Free event node */
125 		list_del(&p->l);
126 		kfree(p);
127 	}
128 }
129 
130 static int counter_set_event_node(struct counter_device *const counter,
131 				  struct counter_watch *const watch,
132 				  const struct counter_comp_node *const cfg)
133 {
134 	struct counter_event_node *event_node;
135 	int err = 0;
136 	struct counter_comp_node *comp_node;
137 
138 	/* Search for event in the list */
139 	list_for_each_entry(event_node, &counter->next_events_list, l)
140 		if (event_node->event == watch->event &&
141 		    event_node->channel == watch->channel)
142 			break;
143 
144 	/* If event is not already in the list */
145 	if (&event_node->l == &counter->next_events_list) {
146 		/* Allocate new event node */
147 		event_node = kmalloc(sizeof(*event_node), GFP_KERNEL);
148 		if (!event_node)
149 			return -ENOMEM;
150 
151 		/* Configure event node and add to the list */
152 		event_node->event = watch->event;
153 		event_node->channel = watch->channel;
154 		INIT_LIST_HEAD(&event_node->comp_list);
155 		list_add(&event_node->l, &counter->next_events_list);
156 	}
157 
158 	/* Check if component watch has already been set before */
159 	list_for_each_entry(comp_node, &event_node->comp_list, l)
160 		if (comp_node->parent == cfg->parent &&
161 		    counter_comp_read_is_equal(comp_node->comp, cfg->comp)) {
162 			err = -EINVAL;
163 			goto exit_free_event_node;
164 		}
165 
166 	/* Allocate component node */
167 	comp_node = kmalloc(sizeof(*comp_node), GFP_KERNEL);
168 	if (!comp_node) {
169 		err = -ENOMEM;
170 		goto exit_free_event_node;
171 	}
172 	*comp_node = *cfg;
173 
174 	/* Add component node to event node */
175 	list_add_tail(&comp_node->l, &event_node->comp_list);
176 
177 exit_free_event_node:
178 	/* Free event node if no one else is watching */
179 	if (list_empty(&event_node->comp_list)) {
180 		list_del(&event_node->l);
181 		kfree(event_node);
182 	}
183 
184 	return err;
185 }
186 
187 static int counter_enable_events(struct counter_device *const counter)
188 {
189 	unsigned long flags;
190 	int err = 0;
191 
192 	mutex_lock(&counter->n_events_list_lock);
193 	spin_lock_irqsave(&counter->events_list_lock, flags);
194 
195 	counter_events_list_free(&counter->events_list);
196 	list_replace_init(&counter->next_events_list,
197 			  &counter->events_list);
198 
199 	if (counter->ops->events_configure)
200 		err = counter->ops->events_configure(counter);
201 
202 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
203 	mutex_unlock(&counter->n_events_list_lock);
204 
205 	return err;
206 }
207 
208 static int counter_disable_events(struct counter_device *const counter)
209 {
210 	unsigned long flags;
211 	int err = 0;
212 
213 	spin_lock_irqsave(&counter->events_list_lock, flags);
214 
215 	counter_events_list_free(&counter->events_list);
216 
217 	if (counter->ops->events_configure)
218 		err = counter->ops->events_configure(counter);
219 
220 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
221 
222 	mutex_lock(&counter->n_events_list_lock);
223 
224 	counter_events_list_free(&counter->next_events_list);
225 
226 	mutex_unlock(&counter->n_events_list_lock);
227 
228 	return err;
229 }
230 
231 static int counter_add_watch(struct counter_device *const counter,
232 			     const unsigned long arg)
233 {
234 	void __user *const uwatch = (void __user *)arg;
235 	struct counter_watch watch;
236 	struct counter_comp_node comp_node = {};
237 	size_t parent, id;
238 	struct counter_comp *ext;
239 	size_t num_ext;
240 	int err = 0;
241 
242 	if (copy_from_user(&watch, uwatch, sizeof(watch)))
243 		return -EFAULT;
244 
245 	if (watch.component.type == COUNTER_COMPONENT_NONE)
246 		goto no_component;
247 
248 	parent = watch.component.parent;
249 
250 	/* Configure parent component info for comp node */
251 	switch (watch.component.scope) {
252 	case COUNTER_SCOPE_DEVICE:
253 		ext = counter->ext;
254 		num_ext = counter->num_ext;
255 		break;
256 	case COUNTER_SCOPE_SIGNAL:
257 		if (parent >= counter->num_signals)
258 			return -EINVAL;
259 		parent = array_index_nospec(parent, counter->num_signals);
260 
261 		comp_node.parent = counter->signals + parent;
262 
263 		ext = counter->signals[parent].ext;
264 		num_ext = counter->signals[parent].num_ext;
265 		break;
266 	case COUNTER_SCOPE_COUNT:
267 		if (parent >= counter->num_counts)
268 			return -EINVAL;
269 		parent = array_index_nospec(parent, counter->num_counts);
270 
271 		comp_node.parent = counter->counts + parent;
272 
273 		ext = counter->counts[parent].ext;
274 		num_ext = counter->counts[parent].num_ext;
275 		break;
276 	default:
277 		return -EINVAL;
278 	}
279 
280 	id = watch.component.id;
281 
282 	/* Configure component info for comp node */
283 	switch (watch.component.type) {
284 	case COUNTER_COMPONENT_SIGNAL:
285 		if (watch.component.scope != COUNTER_SCOPE_SIGNAL)
286 			return -EINVAL;
287 
288 		comp_node.comp.type = COUNTER_COMP_SIGNAL_LEVEL;
289 		comp_node.comp.signal_u32_read = counter->ops->signal_read;
290 		break;
291 	case COUNTER_COMPONENT_COUNT:
292 		if (watch.component.scope != COUNTER_SCOPE_COUNT)
293 			return -EINVAL;
294 
295 		comp_node.comp.type = COUNTER_COMP_U64;
296 		comp_node.comp.count_u64_read = counter->ops->count_read;
297 		break;
298 	case COUNTER_COMPONENT_FUNCTION:
299 		if (watch.component.scope != COUNTER_SCOPE_COUNT)
300 			return -EINVAL;
301 
302 		comp_node.comp.type = COUNTER_COMP_FUNCTION;
303 		comp_node.comp.count_u32_read = counter->ops->function_read;
304 		break;
305 	case COUNTER_COMPONENT_SYNAPSE_ACTION:
306 		if (watch.component.scope != COUNTER_SCOPE_COUNT)
307 			return -EINVAL;
308 		if (id >= counter->counts[parent].num_synapses)
309 			return -EINVAL;
310 		id = array_index_nospec(id, counter->counts[parent].num_synapses);
311 
312 		comp_node.comp.type = COUNTER_COMP_SYNAPSE_ACTION;
313 		comp_node.comp.action_read = counter->ops->action_read;
314 		comp_node.comp.priv = counter->counts[parent].synapses + id;
315 		break;
316 	case COUNTER_COMPONENT_EXTENSION:
317 		if (id >= num_ext)
318 			return -EINVAL;
319 		id = array_index_nospec(id, num_ext);
320 
321 		comp_node.comp = ext[id];
322 		break;
323 	default:
324 		return -EINVAL;
325 	}
326 	if (!counter_comp_read_is_set(comp_node.comp))
327 		return -EOPNOTSUPP;
328 
329 no_component:
330 	mutex_lock(&counter->n_events_list_lock);
331 
332 	if (counter->ops->watch_validate) {
333 		err = counter->ops->watch_validate(counter, &watch);
334 		if (err < 0)
335 			goto err_exit;
336 	}
337 
338 	comp_node.component = watch.component;
339 
340 	err = counter_set_event_node(counter, &watch, &comp_node);
341 
342 err_exit:
343 	mutex_unlock(&counter->n_events_list_lock);
344 
345 	return err;
346 }
347 
348 static long counter_chrdev_ioctl(struct file *filp, unsigned int cmd,
349 				 unsigned long arg)
350 {
351 	struct counter_device *const counter = filp->private_data;
352 	int ret = -ENODEV;
353 
354 	mutex_lock(&counter->ops_exist_lock);
355 
356 	if (!counter->ops)
357 		goto out_unlock;
358 
359 	switch (cmd) {
360 	case COUNTER_ADD_WATCH_IOCTL:
361 		ret = counter_add_watch(counter, arg);
362 		break;
363 	case COUNTER_ENABLE_EVENTS_IOCTL:
364 		ret = counter_enable_events(counter);
365 		break;
366 	case COUNTER_DISABLE_EVENTS_IOCTL:
367 		ret = counter_disable_events(counter);
368 		break;
369 	default:
370 		ret = -ENOIOCTLCMD;
371 		break;
372 	}
373 
374 out_unlock:
375 	mutex_unlock(&counter->ops_exist_lock);
376 
377 	return ret;
378 }
379 
380 static int counter_chrdev_open(struct inode *inode, struct file *filp)
381 {
382 	struct counter_device *const counter = container_of(inode->i_cdev,
383 							    typeof(*counter),
384 							    chrdev);
385 
386 	get_device(&counter->dev);
387 	filp->private_data = counter;
388 
389 	return nonseekable_open(inode, filp);
390 }
391 
392 static int counter_chrdev_release(struct inode *inode, struct file *filp)
393 {
394 	struct counter_device *const counter = filp->private_data;
395 	int ret = 0;
396 
397 	mutex_lock(&counter->ops_exist_lock);
398 
399 	if (!counter->ops) {
400 		/* Free any lingering held memory */
401 		counter_events_list_free(&counter->events_list);
402 		counter_events_list_free(&counter->next_events_list);
403 		ret = -ENODEV;
404 		goto out_unlock;
405 	}
406 
407 	ret = counter_disable_events(counter);
408 	if (ret < 0) {
409 		mutex_unlock(&counter->ops_exist_lock);
410 		return ret;
411 	}
412 
413 out_unlock:
414 	mutex_unlock(&counter->ops_exist_lock);
415 
416 	put_device(&counter->dev);
417 
418 	return ret;
419 }
420 
421 static const struct file_operations counter_fops = {
422 	.owner = THIS_MODULE,
423 	.llseek = no_llseek,
424 	.read = counter_chrdev_read,
425 	.poll = counter_chrdev_poll,
426 	.unlocked_ioctl = counter_chrdev_ioctl,
427 	.open = counter_chrdev_open,
428 	.release = counter_chrdev_release,
429 };
430 
431 int counter_chrdev_add(struct counter_device *const counter)
432 {
433 	/* Initialize Counter events lists */
434 	INIT_LIST_HEAD(&counter->events_list);
435 	INIT_LIST_HEAD(&counter->next_events_list);
436 	spin_lock_init(&counter->events_list_lock);
437 	mutex_init(&counter->n_events_list_lock);
438 	init_waitqueue_head(&counter->events_wait);
439 	spin_lock_init(&counter->events_in_lock);
440 	mutex_init(&counter->events_out_lock);
441 
442 	/* Initialize character device */
443 	cdev_init(&counter->chrdev, &counter_fops);
444 
445 	/* Allocate Counter events queue */
446 	return kfifo_alloc(&counter->events, 64, GFP_KERNEL);
447 }
448 
449 void counter_chrdev_remove(struct counter_device *const counter)
450 {
451 	kfifo_free(&counter->events);
452 }
453 
454 static int counter_get_data(struct counter_device *const counter,
455 			    const struct counter_comp_node *const comp_node,
456 			    u64 *const value)
457 {
458 	const struct counter_comp *const comp = &comp_node->comp;
459 	void *const parent = comp_node->parent;
460 	u8 value_u8 = 0;
461 	u32 value_u32 = 0;
462 	int ret;
463 
464 	if (comp_node->component.type == COUNTER_COMPONENT_NONE)
465 		return 0;
466 
467 	switch (comp->type) {
468 	case COUNTER_COMP_U8:
469 	case COUNTER_COMP_BOOL:
470 		switch (comp_node->component.scope) {
471 		case COUNTER_SCOPE_DEVICE:
472 			ret = comp->device_u8_read(counter, &value_u8);
473 			break;
474 		case COUNTER_SCOPE_SIGNAL:
475 			ret = comp->signal_u8_read(counter, parent, &value_u8);
476 			break;
477 		case COUNTER_SCOPE_COUNT:
478 			ret = comp->count_u8_read(counter, parent, &value_u8);
479 			break;
480 		default:
481 			return -EINVAL;
482 		}
483 		*value = value_u8;
484 		return ret;
485 	case COUNTER_COMP_SIGNAL_LEVEL:
486 	case COUNTER_COMP_FUNCTION:
487 	case COUNTER_COMP_ENUM:
488 	case COUNTER_COMP_COUNT_DIRECTION:
489 	case COUNTER_COMP_COUNT_MODE:
490 		switch (comp_node->component.scope) {
491 		case COUNTER_SCOPE_DEVICE:
492 			ret = comp->device_u32_read(counter, &value_u32);
493 			break;
494 		case COUNTER_SCOPE_SIGNAL:
495 			ret = comp->signal_u32_read(counter, parent,
496 						    &value_u32);
497 			break;
498 		case COUNTER_SCOPE_COUNT:
499 			ret = comp->count_u32_read(counter, parent, &value_u32);
500 			break;
501 		default:
502 			return -EINVAL;
503 		}
504 		*value = value_u32;
505 		return ret;
506 	case COUNTER_COMP_U64:
507 		switch (comp_node->component.scope) {
508 		case COUNTER_SCOPE_DEVICE:
509 			return comp->device_u64_read(counter, value);
510 		case COUNTER_SCOPE_SIGNAL:
511 			return comp->signal_u64_read(counter, parent, value);
512 		case COUNTER_SCOPE_COUNT:
513 			return comp->count_u64_read(counter, parent, value);
514 		default:
515 			return -EINVAL;
516 		}
517 	case COUNTER_COMP_SYNAPSE_ACTION:
518 		ret = comp->action_read(counter, parent, comp->priv,
519 					&value_u32);
520 		*value = value_u32;
521 		return ret;
522 	default:
523 		return -EINVAL;
524 	}
525 }
526 
527 /**
528  * counter_push_event - queue event for userspace reading
529  * @counter:	pointer to Counter structure
530  * @event:	triggered event
531  * @channel:	event channel
532  *
533  * Note: If no one is watching for the respective event, it is silently
534  * discarded.
535  */
536 void counter_push_event(struct counter_device *const counter, const u8 event,
537 			const u8 channel)
538 {
539 	struct counter_event ev;
540 	unsigned int copied = 0;
541 	unsigned long flags;
542 	struct counter_event_node *event_node;
543 	struct counter_comp_node *comp_node;
544 
545 	ev.timestamp = ktime_get_ns();
546 	ev.watch.event = event;
547 	ev.watch.channel = channel;
548 
549 	/* Could be in an interrupt context, so use a spin lock */
550 	spin_lock_irqsave(&counter->events_list_lock, flags);
551 
552 	/* Search for event in the list */
553 	list_for_each_entry(event_node, &counter->events_list, l)
554 		if (event_node->event == event &&
555 		    event_node->channel == channel)
556 			break;
557 
558 	/* If event is not in the list */
559 	if (&event_node->l == &counter->events_list)
560 		goto exit_early;
561 
562 	/* Read and queue relevant comp for userspace */
563 	list_for_each_entry(comp_node, &event_node->comp_list, l) {
564 		ev.watch.component = comp_node->component;
565 		ev.status = -counter_get_data(counter, comp_node, &ev.value);
566 
567 		copied += kfifo_in_spinlocked_noirqsave(&counter->events, &ev,
568 							1, &counter->events_in_lock);
569 	}
570 
571 exit_early:
572 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
573 
574 	if (copied)
575 		wake_up_poll(&counter->events_wait, EPOLLIN);
576 }
577 EXPORT_SYMBOL_GPL(counter_push_event);
578