Introduce the Counter character device interface

This is a reimplementation of the Generic Counter driver interface.

drivers/counter/counter-core.c new file +36 -0

new file mode 100644
index 000000000000..987c6e8277eb
 
 
+/**
+ * counter_register - register Counter to the system
+ * @counter:	pointer to Counter to register
+ *
+ * This function registers a Counter to the system. A sysfs "counter" directory
+ * will be created and populated with sysfs attributes correlating with the
+ * Counter Signals, Synapses, and Counts respectively.
+ */
+int counter_register(struct counter_device *const counter)
+{
+	struct device *const dev = &counter->dev;
+	int err;
+
+	/* Acquire unique ID */
+	counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+	if (counter->id < 0)
+		return counter->id;
+
+	/* Configure device structure for Counter */
+	dev->type = &counter_device_type;
+	dev->bus = &counter_bus_type;
+	if (counter->parent) {
+		dev->parent = counter->parent;
+		dev->of_node = counter->parent->of_node;
+	}
+	dev_set_name(dev, "counter%d", counter->id);
+	device_initialize(dev);> +	dev_set_drvdata(dev, counter);
+
+	/* Add Counter sysfs attributes */
+	err = counter_sysfs_add(counter);
+	if (err)
+		goto err_free_id;
+
+	/* Add device to system */
+	err = device_add(dev);
+	if (err) {

drivers/counter/counter-core.c new file +10 -0

+	return err;
+}
+EXPORT_SYMBOL_GPL(counter_register);
+
+/**
+ * counter_unregister - unregister Counter from the system
+ * @counter:	pointer to Counter to unregister
+ *
+ * The Counter is unregistered from the system; all allocated memory is freed.
+ */

drivers/counter/counter-core.c new file +4 -0

+{
+	counter_unregister(*(struct counter_device **)res);
+}
+

drivers/counter/counter-sysfs.c new file +5 -0

new file mode 100644
index 000000000000..e66ed99dd5ea
 
+/**
+ * counter_sysfs_add - Adds Counter sysfs attributes to the device structure
+ * @counter:	Pointer to the Counter device structure
+ *
+ * Counter sysfs attributes are created and added to the respective device

drivers/counter/counter-sysfs.c new file +7 -0

+	struct counter_attribute_group *groups;
+	size_t i, j;
+	int err;
+	struct attribute_group *group;
+	struct counter_attribute *p;
+
+	/* Allocate space for attribute groups (signals, counts, and ext) */

drivers/counter/ti-eqep.c +0 -0

index 1ff07faef27f..938085dead80 100644

Quoted 1 line · William Breathitt Gray

This is a reimplementation of the Generic Counter driver interface.

I'll follow up if I find any problems while testing but here are some comments I had from looking over the patch.

Quoted 49 lines

drivers/counter/counter-core.c new file +42 -0

new file mode 100644
index 000000000000..987c6e8277eb
 
 
+/**
+ * counter_register - register Counter to the system
+ * @counter:	pointer to Counter to register
+ *
+ * This function registers a Counter to the system. A sysfs "counter" directory
+ * will be created and populated with sysfs attributes correlating with the
+ * Counter Signals, Synapses, and Counts respectively.
+ */
+int counter_register(struct counter_device *const counter)
+{
+	struct device *const dev = &counter->dev;
+	int err;
+
+	/* Acquire unique ID */
+	counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+	if (counter->id < 0)
+		return counter->id;
+
+	/* Configure device structure for Counter */
+	dev->type = &counter_device_type;
+	dev->bus = &counter_bus_type;
+	if (counter->parent) {
+		dev->parent = counter->parent;
+		dev->of_node = counter->parent->of_node;
+	}
+	dev_set_name(dev, "counter%d", counter->id);
+	device_initialize(dev);> +	dev_set_drvdata(dev, counter);
+
+	/* Add Counter sysfs attributes */
+	err = counter_sysfs_add(counter);
+	if (err)
+		goto err_free_id;
+
+	/* Add device to system */
+	err = device_add(dev);
+	if (err) {
+		put_device(dev);
+		goto err_free_id;
+	}
+
+	return 0;
+

drivers/counter/counter-core.c line 81

Quoted 4 lines

drivers/counter/counter-core.c new file +4 -0

+err_free_id:
+	/* get_device/put_device combo used to free managed resources */
+	get_device(dev);
+	put_device(dev);

I've never seen this in a driver before, so it makes me think this is not the "right way" to do this. After device_initialize() is called, we already should have a reference to dev, so only device_put() is needed.

drivers/counter/counter-core.c

Quoted 1 line

drivers/counter/counter-core.c new file +1 -0

+	ida_simple_remove(&counter_ida, counter->id);

In the case of error after device_initialize() is called, won't this result in ida_simple_remove() being called twice, once here and once in the release callback?

Quoted 14 lines

drivers/counter/counter-core.c new file +14 -0

+	return err;
+}
+EXPORT_SYMBOL_GPL(counter_register);
+
+/**
+ * counter_unregister - unregister Counter from the system
+ * @counter:	pointer to Counter to unregister
+ *
+ * The Counter is unregistered from the system; all allocated memory is freed.
+ */
+void counter_unregister(struct counter_device *const counter)
+{
+	if (!counter)
+		return;

drivers/counter/counter-core.c line 102

Quoted 6 lines

drivers/counter/counter-core.c new file +6 -0

+
+	device_unregister(&counter->dev);
+}
+EXPORT_SYMBOL_GPL(counter_unregister);
+
+static void devm_counter_unreg(struct device *dev, void *res)

To be consistent, it would be nice to spell out unregister.

Quoted 20 lines

drivers/counter/counter-core.c new file +4 -0

+{
+	counter_unregister(*(struct counter_device **)res);
+}
+

drivers/counter/counter-sysfs.c new file +9 -0

new file mode 100644
index 000000000000..e66ed99dd5ea
 
+/**
+ * counter_sysfs_add - Adds Counter sysfs attributes to the device structure
+ * @counter:	Pointer to the Counter device structure
+ *
+ * Counter sysfs attributes are created and added to the respective device
+ * structure for later registration to the system. Resource-managed memory
+ * allocation is performed by this function, and this memory should be freed
+ * when no longer needed (automatically by a device_unregister call, or
+ * manually by a devres_release_all call).

drivers/counter/counter-sysfs.c line 722

Quoted 6 lines

+ */

drivers/counter/counter-sysfs.c new file +5 -0

+int counter_sysfs_add(struct counter_device *const counter)
+{
+	struct device *const dev = &counter->dev;
+	const size_t num_groups = counter->num_signals + counter->num_counts +
+				  1;

It is OK to go past 80 columns, especially for just for a few characters.

Quoted 14 lines

drivers/counter/counter-sysfs.c new file +14 -0

+	struct counter_attribute_group *groups;
+	size_t i, j;
+	int err;
+	struct attribute_group *group;
+	struct counter_attribute *p;
+
+	/* Allocate space for attribute groups (signals, counts, and ext) */
+	groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL);
+	if (!groups)
+		return -ENOMEM;
+
+	/* Initialize attribute lists */
+	for (i = 0; i < num_groups; i++)
+		INIT_LIST_HEAD(&groups[i].attr_list);

drivers/counter/counter-sysfs.c line 739

Quoted 3 lines

drivers/counter/counter-sysfs.c new file +3 -0

+
+	/* Register Counter device attributes */
+	err = counter_device_register(counter, groups);

This function name is a bit misleading. At first I though we were registering a new counter device (struct device). Maybe counter_sysfs_create_attrs() would be a better name? (I wouldn't mind having all functions in this file having a "counter_sysfs_" prefix for that matter.)

Quoted 8 lines

drivers/counter/ti-eqep.c +0 -0

index 1ff07faef27f..938085dead80 100644
@@ -406,7 +414,7 @@ static int ti_eqep_probe(struct platform_device *pdev)
 

drivers/counter/ti-eqep.c static int ti_eqep_probe(struct platform_device *pdev) · line 420

Quoted 7 lines

drivers/counter/ti-eqep.c +1 -1

  	priv->counter.name = dev_name(dev);
  	priv->counter.parent = dev;
-	priv->counter.ops = &ti_eqep_counter_ops;
+	priv->counter.parent = &ti_eqep_counter_ops;
  	priv->counter.counts = ti_eqep_counts;
  	priv->counter.num_counts = ARRAY_SIZE(ti_eqep_counts);
  	priv->counter.signals = ti_eqep_signals;

This looks like an unintentional change and causes a compile error.

Quoted 8 lines

include/linux/counter.h +0 -0

index 9dbd5df4cd34..132bfecca5c3 100644
@@ -6,417 +6,195 @@
  #ifndef _COUNTER_H_
  #define _COUNTER_H_
 

include/linux/counter.h line 11

Quoted 4 lines

include/linux/counter.h +2 -1

-#include <linux/counter_enum.h>
  #include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/list.h>

struct list_head is defined in linux/types.h. Is there something else we are using from linux/list.h in this file?

include/linux/counter.h line 13

Quoted 2 lines

include/linux/counter.h +0 -0

  #include <linux/types.h>
 

It would be helpful to have kernel doc comments on everything in this file.

Quoted 55 lines · David Lechner

Quoted 1 line · William Breathitt Gray

This is a reimplementation of the Generic Counter driver interface.

I'll follow up if I find any problems while testing but here are some comments I had from looking over the patch.

Quoted 49 lines

drivers/counter/counter-core.c new file +42 -0

new file mode 100644
index 000000000000..987c6e8277eb
 
 
+/**
+ * counter_register - register Counter to the system
+ * @counter:	pointer to Counter to register
+ *
+ * This function registers a Counter to the system. A sysfs "counter" directory
+ * will be created and populated with sysfs attributes correlating with the
+ * Counter Signals, Synapses, and Counts respectively.
+ */
+int counter_register(struct counter_device *const counter)
+{
+	struct device *const dev = &counter->dev;
+	int err;
+
+	/* Acquire unique ID */
+	counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+	if (counter->id < 0)
+		return counter->id;
+
+	/* Configure device structure for Counter */
+	dev->type = &counter_device_type;
+	dev->bus = &counter_bus_type;
+	if (counter->parent) {
+		dev->parent = counter->parent;
+		dev->of_node = counter->parent->of_node;
+	}
+	dev_set_name(dev, "counter%d", counter->id);
+	device_initialize(dev);> +	dev_set_drvdata(dev, counter);
+
+	/* Add Counter sysfs attributes */
+	err = counter_sysfs_add(counter);
+	if (err)
+		goto err_free_id;
+
+	/* Add device to system */
+	err = device_add(dev);
+	if (err) {
+		put_device(dev);
+		goto err_free_id;
+	}
+
+	return 0;
+

Quoted 8 lines

drivers/counter/counter-core.c line 81

Quoted 4 lines

drivers/counter/counter-core.c new file +4 -0

+err_free_id:
+	/* get_device/put_device combo used to free managed resources */
+	get_device(dev);
+	put_device(dev);

I've never seen this in a driver before, so it makes me think this is not the "right way" to do this. After device_initialize() is called, we already should have a reference to dev, so only device_put() is needed.

I do admit this feels very hacky, but I'm not sure how to handle this more elegantly. The problem is that device_initialize() is not enough by itself -- it just initializes the structure, while device_add() increments the reference count via a call to get_device().

So let's assume counter_sysfs_add() fails and we go to err_free_id before device_add() is called; if we ignore get_device(), the reference count will be 0 at this point. We then call put_device(), which calls kobject_put(), kref_put(), and eventually refcount_dec_and_test().

The refcount_dec_and_test() function returns 0 at this point because the reference count can't be decremented further (refcount is already 0), so release() is never called and we end up leaking all the memory we allocated in counter_sysfs_add().

Is my logic correct here?

Quoted 60 lines · William Breathitt Gray

Quoted 50 lines · David Lechner

Quoted 49 lines · William Breathitt Gray

drivers/counter/counter-core.c new file +42 -0

new file mode 100644
index 000000000000..987c6e8277eb
 
 
+/**
+ * counter_register - register Counter to the system
+ * @counter:	pointer to Counter to register
+ *
+ * This function registers a Counter to the system. A sysfs "counter" directory
+ * will be created and populated with sysfs attributes correlating with the
+ * Counter Signals, Synapses, and Counts respectively.
+ */
+int counter_register(struct counter_device *const counter)
+{
+	struct device *const dev = &counter->dev;
+	int err;
+
+	/* Acquire unique ID */
+	counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+	if (counter->id < 0)
+		return counter->id;
+
+	/* Configure device structure for Counter */
+	dev->type = &counter_device_type;
+	dev->bus = &counter_bus_type;
+	if (counter->parent) {
+		dev->parent = counter->parent;
+		dev->of_node = counter->parent->of_node;
+	}
+	dev_set_name(dev, "counter%d", counter->id);
+	device_initialize(dev);> +	dev_set_drvdata(dev, counter);
+
+	/* Add Counter sysfs attributes */
+	err = counter_sysfs_add(counter);
+	if (err)
+		goto err_free_id;
+
+	/* Add device to system */
+	err = device_add(dev);
+	if (err) {
+		put_device(dev);
+		goto err_free_id;
+	}
+
+	return 0;
+

Quoted 8 lines

drivers/counter/counter-core.c line 81

Quoted 4 lines

drivers/counter/counter-core.c new file +4 -0

+err_free_id:
+	/* get_device/put_device combo used to free managed resources */
+	get_device(dev);
+	put_device(dev);

I've never seen this in a driver before, so it makes me think this is not the "right way" to do this. After device_initialize() is called, we already should have a reference to dev, so only device_put() is needed.

Quoted 4 lines

I do admit this feels very hacky, but I'm not sure how to handle this more elegantly. The problem is that device_initialize() is not enough by itself -- it just initializes the structure, while device_add() increments the reference count via a call to get_device().

add_device() also releases this reference by calling put_device() in all return paths. The reference count is initialized to 1 in device_initialize().

device_initialize > kobject_init > kobject_init_internal > kref_init

Quoted 11 lines

So let's assume counter_sysfs_add() fails and we go to err_free_id before device_add() is called; if we ignore get_device(), the reference count will be 0 at this point. We then call put_device(), which calls kobject_put(), kref_put(), and eventually refcount_dec_and_test().

The refcount_dec_and_test() function returns 0 at this point because the reference count can't be decremented further (refcount is already 0), so release() is never called and we end up leaking all the memory we allocated in counter_sysfs_add().

Quoted 1 line

Is my logic correct here?

Not quite. I think you missed a few things I mentioned above. So we never have a ref count of 0 until the very last call to put_device().

drivers/counter/counter-sysfs.c new file +31 -0

+static ssize_t counter_comp_u8_store(struct device *dev,
+				     struct device_attribute *attr,
+				     const char *buf, size_t len)
+{
+	const struct counter_attribute *const a = to_counter_attribute(attr);
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = a->parent;
+	struct counter_synapse *const synapse = a->comp.priv;
+	const struct counter_available *const avail = a->comp.priv;
+	int err;
+	bool bool_data;
+	u8 data;
+
+	switch (a->comp.type) {
+	case COUNTER_COMP_BOOL:
+		err = kstrtobool(buf, &bool_data);
+		data = bool_data;
+		break;
+	case COUNTER_COMP_FUNCTION:
+		err = find_in_string_array(&data, count->functions_list,
+					   count->num_functions, buf,
+					   counter_function_str);
+		break;
+	case COUNTER_COMP_SYNAPSE_ACTION:
+		err = find_in_string_array(&data, synapse->actions_list,
+					   synapse->num_actions, buf,
+					   counter_synapse_action_str);
+		break;
+	case COUNTER_COMP_ENUM:
+		err = __sysfs_match_string(avail->strs, avail->num_items, buf);
+		data = err;

drivers/counter/counter-sysfs.c new file +23 -0

+	if (err)
+		return err;
+
+	switch (a->scope) {
+	case COUNTER_SCOPE_DEVICE:
+		err = a->comp.device_u8_write(counter, data);
+		break;
+	case COUNTER_SCOPE_SIGNAL:
+		err = a->comp.signal_u8_write(counter, a->parent, data);
+		break;
+	case COUNTER_SCOPE_COUNT:
+		if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
+			err = a->comp.action_write(counter, count, synapse,
+						   data);
+		else
+			err = a->comp.count_u8_write(counter, count, data);
+		break;
+	}
+	if (err)
+		return err;
+
+	return len;
+}

Quoted 31 lines · William Breathitt Gray

drivers/counter/counter-sysfs.c new file +31 -0

+static ssize_t counter_comp_u8_store(struct device *dev,
+				     struct device_attribute *attr,
+				     const char *buf, size_t len)
+{
+	const struct counter_attribute *const a = to_counter_attribute(attr);
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = a->parent;
+	struct counter_synapse *const synapse = a->comp.priv;
+	const struct counter_available *const avail = a->comp.priv;
+	int err;
+	bool bool_data;
+	u8 data;
+
+	switch (a->comp.type) {
+	case COUNTER_COMP_BOOL:
+		err = kstrtobool(buf, &bool_data);
+		data = bool_data;
+		break;
+	case COUNTER_COMP_FUNCTION:
+		err = find_in_string_array(&data, count->functions_list,
+					   count->num_functions, buf,
+					   counter_function_str);
+		break;
+	case COUNTER_COMP_SYNAPSE_ACTION:
+		err = find_in_string_array(&data, synapse->actions_list,
+					   synapse->num_actions, buf,
+					   counter_synapse_action_str);
+		break;
+	case COUNTER_COMP_ENUM:
+		err = __sysfs_match_string(avail->strs, avail->num_items, buf);
+		data = err;

drivers/counter/counter-sysfs.c line 189

Quoted 10 lines

drivers/counter/counter-sysfs.c new file +10 -0

+		break;
+	case COUNTER_COMP_COUNT_MODE:
+		err = find_in_string_array(&data, avail->enums,
+					   avail->num_items, buf,
+					   counter_count_mode_str);
+		break;
+	default:
+		err = kstrtou8(buf, 0, &data);
+		break;
+	}

In this function, return values are not always errors. So it would make sense to call the err variable ret instead and check for ret < 0 below.

Setting enums to a value with index > 0 fails currently because of this.

Quoted 23 lines

drivers/counter/counter-sysfs.c new file +23 -0

+	if (err)
+		return err;
+
+	switch (a->scope) {
+	case COUNTER_SCOPE_DEVICE:
+		err = a->comp.device_u8_write(counter, data);
+		break;
+	case COUNTER_SCOPE_SIGNAL:
+		err = a->comp.signal_u8_write(counter, a->parent, data);
+		break;
+	case COUNTER_SCOPE_COUNT:
+		if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
+			err = a->comp.action_write(counter, count, synapse,
+						   data);
+		else
+			err = a->comp.count_u8_write(counter, count, data);
+		break;
+	}
+	if (err)
+		return err;
+
+	return len;
+}

This patch introduces a character device interface for the Counter subsystem. Device data is exposed through standard character device read operations. Device data is gathered when a Counter event is pushed by the respective Counter device driver. Configuration is handled via ioctl operations on the respective Counter character device node.

drivers/counter/counter-chrdev.c new file +24 -0

new file mode 100644
index 000000000000..2be3846e4105
 
 
+
+static int counter_set_event_node(struct counter_device *const counter,
+				  struct counter_watch *const watch,
+				  const struct counter_comp_node *const cfg)
+{
+	struct counter_event_node *event_node;
+	int err;
+	struct counter_comp_node *comp_node;
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->next_events_list, l)
+		if (event_node->event == watch->event &&
+		    event_node->channel == watch->channel)
+			break;
+
+	/* If event is not already in the list */
+	if (&event_node->l == &counter->next_events_list) {
+		/* Allocate new event node */
+		event_node = kmalloc(sizeof(*event_node), GFP_ATOMIC);
+		if (!event_node)
+			return -ENOMEM;
+
+		/* Configure event node and add to the list */
+		event_node->event = watch->event;

drivers/counter/counter-chrdev.c new file +22 -0

+	if (list_empty(&event_node->comp_list)) {
+		list_del(&event_node->l);
+		kfree(event_node);
+	}
+	return err;
+}
+
+static int counter_set_watch(struct counter_device *const counter,
+			     const unsigned long arg)
+{
+	void __user *const uwatch = (void __user *)arg;
+	struct counter_watch watch;
+	struct counter_comp_node comp_node;
+	size_t parent, id;
+	struct counter_comp *ext;
+	size_t num_ext;
+
+	if (copy_from_user(&watch, uwatch, sizeof(watch)))
+		return -EFAULT;
+	parent = watch.component.parent;
+	id = watch.component.id;
+

drivers/counter/counter-chrdev.c new file +28 -0

+			return -EINVAL;
+
+		comp_node.parent = counter->counts + parent;
+
+		ext = counter->counts[parent].ext;
+		num_ext = counter->counts[parent].num_ext;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	/* Configure component info for comp node */
+	switch (watch.component.type) {
+	case COUNTER_COMPONENT_SIGNAL:
+		if (watch.component.scope != COUNTER_SCOPE_SIGNAL)
+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_SIGNAL_LEVEL;
+		comp_node.comp.signal_u8_read = counter->ops->signal_read;
+		break;
+	case COUNTER_COMPONENT_COUNT:
+		if (watch.component.scope != COUNTER_SCOPE_COUNT)
+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_U64;
+		comp_node.comp.count_u64_read = counter->ops->count_read;
+		break;
+	case COUNTER_COMPONENT_FUNCTION:

drivers/counter/counter-chrdev.c new file +10 -0

+	comp_node.component = watch.component;
+
+	return counter_set_event_node(counter, &watch, &comp_node);
+}
+
+static long counter_chrdev_ioctl(struct file *filp, unsigned int cmd,
+				 unsigned long arg)
+{
+	struct counter_device *const counter = filp->private_data;
+	raw_spinlock_t *const events_lock = &counter->events_lock;

drivers/counter/counter-chrdev.c new file +16 -0

+		break;
+	default:
+		return -ENOIOCTLCMD;
+	}
+
+	return 0;
+}
+
+static int counter_chrdev_open(struct inode *inode, struct file *filp)
+{
+	struct counter_device *const counter = container_of(inode->i_cdev,
+							    typeof(*counter),
+							    chrdev);
+
+	get_device(&counter->dev);
+	filp->private_data = counter;

drivers/counter/counter-chrdev.c new file +47 -0

+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+	counter_events_list_free(&counter->events_list);
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+	counter_events_list_free(&counter->next_events_list);
+
+	return 0;
+}
+
 
+int counter_push_event(struct counter_device *const counter, const u8 event,
+		       const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+	int err;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->events_list, l)
+		if (event_node->event == event &&
+		    event_node->channel == channel)
+			break;
+
+	/* If event is not in the list */
+	if (&event_node->l == &counter->events_list)
+		goto exit_early;
+
+	/* Read and queue relevant comp for userspace */
+	list_for_each_entry(comp_node, &event_node->comp_list, l) {
+		err = counter_get_data(counter, comp_node, &ev.value_u8);
+		if (err)
+			goto err_counter_get_data;
+
+		ev.watch.component = comp_node->component;
+
+		copied += kfifo_put(&counter->events, ev);
+	}
+
+	if (copied)

include/uapi/linux/counter.h new file +0 -0

new file mode 100644
index 000000000000..ad9a8686b2b0

include/uapi/linux/counter.h new file +4 -0

+
+/**
+ * struct counter_component - Counter component identification
+ * @scope: component scope (Device, Count, or Signal)

include/uapi/linux/counter.h new file +10 -0

+
+#define COUNTER_CLEAR_WATCHES_IOCTL _IO(0x3E, 0x00)
+#define COUNTER_SET_WATCH_IOCTL _IOW(0x3E, 0x01, struct counter_watch)
+#define COUNTER_LOAD_WATCHES_IOCTL _IO(0x3E, 0x02)
+
+/**
+ * struct counter_event - Counter event data
+ * @timestamp: best estimate of time of event occurrence, in nanoseconds
+ * @watch: component watch configuration
+ * @value_u8: component value as __u8 data type

include/uapi/linux/counter.h new file +17 -0

+
+#define COUNTER_COUNT_DIRECTION_FORWARD 0
+#define COUNTER_COUNT_DIRECTION_BACKWARD 1
+
+#define COUNTER_COUNT_MODE_NORMAL 0
+#define COUNTER_COUNT_MODE_RANGE_LIMIT 1
+#define COUNTER_COUNT_MODE_NON_RECYCLE 2
+#define COUNTER_COUNT_MODE_MODULO_N 3
+
+#define COUNTER_FUNCTION_INCREASE 0
+#define COUNTER_FUNCTION_DECREASE 1
+#define COUNTER_FUNCTION_PULSE_DIRECTION 2
+#define COUNTER_FUNCTION_QUADRATURE_X1_A 3
+#define COUNTER_FUNCTION_QUADRATURE_X1_B 4
+#define COUNTER_FUNCTION_QUADRATURE_X2_A 5
+#define COUNTER_FUNCTION_QUADRATURE_X2_B 6
+#define COUNTER_FUNCTION_QUADRATURE_X4 7

Quoted 6 lines · William Breathitt Gray

This patch introduces a character device interface for the Counter subsystem. Device data is exposed through standard character device read operations. Device data is gathered when a Counter event is pushed by the respective Counter device driver. Configuration is handled via ioctl operations on the respective Counter character device node.

Probably don't need to duplicate the full documentation in the commit message.

Quoted 36 lines

drivers/counter/counter-chrdev.c new file +29 -0

new file mode 100644
index 000000000000..2be3846e4105
 
 
+
+static int counter_set_event_node(struct counter_device *const counter,
+				  struct counter_watch *const watch,
+				  const struct counter_comp_node *const cfg)
+{
+	struct counter_event_node *event_node;
+	int err;
+	struct counter_comp_node *comp_node;
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->next_events_list, l)
+		if (event_node->event == watch->event &&
+		    event_node->channel == watch->channel)
+			break;
+
+	/* If event is not already in the list */
+	if (&event_node->l == &counter->next_events_list) {
+		/* Allocate new event node */
+		event_node = kmalloc(sizeof(*event_node), GFP_ATOMIC);
+		if (!event_node)
+			return -ENOMEM;
+
+		/* Configure event node and add to the list */
+		event_node->event = watch->event;
+		event_node->channel = watch->channel;
+		INIT_LIST_HEAD(&event_node->comp_list);
+		list_add(&event_node->l, &counter->next_events_list);
+	}
+

drivers/counter/counter-chrdev.c line 137

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+	/* Check if component watch has already been set before */
+	list_for_each_entry(comp_node, &event_node->comp_list, l)
+		if (comp_node->parent == cfg->parent &&
+		    comp_node->comp.count_u8_read == cfg->comp.count_u8_read)
+			return -EINVAL;

There are already enough things that could cause EINVAL, we could probably skip this duplicate check to make troubleshooting easier.

drivers/counter/counter-chrdev.c line 143

Quoted 6 lines

drivers/counter/counter-chrdev.c new file +6 -0

+
+	/* Allocate component node */
+	comp_node = kmalloc(sizeof(*comp_node), GFP_ATOMIC);
+	if (!comp_node) {
+		err = -ENOMEM;
+		goto err_comp_node;

Since there is only one goto, we could just handle the error and return here instead.

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+	}
+	*comp_node = *cfg;
+
+	/* Add component node to event node */
+	list_add_tail(&comp_node->l, &event_node->comp_list);

drivers/counter/counter-chrdev.c line 152

Quoted 4 lines

drivers/counter/counter-chrdev.c new file +4 -0

+
+	return 0;
+
+err_comp_node:

A comment explaining the list_empty() check would be nice. It makes sense if you think about it, but it is not super obvious.

Quoted 22 lines

drivers/counter/counter-chrdev.c new file +22 -0

+	if (list_empty(&event_node->comp_list)) {
+		list_del(&event_node->l);
+		kfree(event_node);
+	}
+	return err;
+}
+
+static int counter_set_watch(struct counter_device *const counter,
+			     const unsigned long arg)
+{
+	void __user *const uwatch = (void __user *)arg;
+	struct counter_watch watch;
+	struct counter_comp_node comp_node;
+	size_t parent, id;
+	struct counter_comp *ext;
+	size_t num_ext;
+
+	if (copy_from_user(&watch, uwatch, sizeof(watch)))
+		return -EFAULT;
+	parent = watch.component.parent;
+	id = watch.component.id;
+

drivers/counter/counter-chrdev.c line 184

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+	/* Configure parent component info for comp node */
+	switch (watch.component.scope) {
+	case COUNTER_SCOPE_DEVICE:
+		comp_node.parent = NULL;
+
+		ext = counter->ext;
+		num_ext = counter->num_ext;
+		break;
+	case COUNTER_SCOPE_SIGNAL:
+		if (counter->num_signals < parent + 1)

I think it would be more conventional this way:

	if (parent >= counter->num_signals)

drivers/counter/counter-chrdev.c line 193

Quoted 9 lines

drivers/counter/counter-chrdev.c new file +9 -0

+			return -EINVAL;
+
+		comp_node.parent = counter->signals + parent;
+
+		ext = counter->signals[parent].ext;
+		num_ext = counter->signals[parent].num_ext;
+		break;
+	case COUNTER_SCOPE_COUNT:
+		if (counter->num_counts < parent + 1)

Same here.

Quoted 32 lines

drivers/counter/counter-chrdev.c new file +32 -0

+			return -EINVAL;
+
+		comp_node.parent = counter->counts + parent;
+
+		ext = counter->counts[parent].ext;
+		num_ext = counter->counts[parent].num_ext;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	/* Configure component info for comp node */
+	switch (watch.component.type) {
+	case COUNTER_COMPONENT_SIGNAL:
+		if (watch.component.scope != COUNTER_SCOPE_SIGNAL)
+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_SIGNAL_LEVEL;
+		comp_node.comp.signal_u8_read = counter->ops->signal_read;
+		break;
+	case COUNTER_COMPONENT_COUNT:
+		if (watch.component.scope != COUNTER_SCOPE_COUNT)
+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_U64;
+		comp_node.comp.count_u64_read = counter->ops->count_read;
+		break;
+	case COUNTER_COMPONENT_FUNCTION:
+		if (watch.component.scope != COUNTER_SCOPE_COUNT)
+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_FUNCTION;

drivers/counter/counter-chrdev.c line 231

Quoted 6 lines

drivers/counter/counter-chrdev.c new file +6 -0

+		comp_node.comp.count_u8_read = counter->ops->function_read;
+		break;
+	case COUNTER_COMPONENT_SYNAPSE_ACTION:
+		if (watch.component.scope != COUNTER_SCOPE_COUNT)
+			return -EINVAL;
+		if (counter->counts[parent].num_synapses < id + 1)

	if (id >= counter->counts[parent].num_synapses)

drivers/counter/counter-chrdev.c line 239

Quoted 8 lines

drivers/counter/counter-chrdev.c new file +8 -0

+			return -EINVAL;
+
+		comp_node.comp.type = COUNTER_COMP_SYNAPSE_ACTION;
+		comp_node.comp.action_read = counter->ops->action_read;
+		comp_node.comp.priv = counter->counts[parent].synapses + id;
+		break;
+	case COUNTER_COMPONENT_EXTENSION:
+		if (num_ext < id + 1)

	if (id >= num_ext)

Quoted 4 lines

drivers/counter/counter-chrdev.c new file +4 -0

+			return -EINVAL;
+
+		comp_node.comp = ext[id];
+		break;

drivers/counter/counter-chrdev.c line 247

Quoted 4 lines

drivers/counter/counter-chrdev.c new file +4 -0

+	default:
+		return -EINVAL;
+	}
+	if (!comp_node.comp.count_u8_read)

A comment reminding us that count_u8_read is part of a union would be helpful here since this is checking that any read function was set, not just count_u8_read.

drivers/counter/counter-chrdev.c

Quoted 1 line

drivers/counter/counter-chrdev.c new file +1 -0

+		return -EFAULT;

Would EOPNOTSUPP be a better error choice?

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+	comp_node.component = watch.component;
+
+	return counter_set_event_node(counter, &watch, &comp_node);
+}
+
+static long counter_chrdev_ioctl(struct file *filp, unsigned int cmd,
+				 unsigned long arg)
+{
+	struct counter_device *const counter = filp->private_data;
+	raw_spinlock_t *const events_lock = &counter->events_lock;

drivers/counter/counter-chrdev.c line 268

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+	unsigned long flags;
+	struct list_head *const events_list = &counter->events_list;
+	struct list_head *const next_events_list = &counter->next_events_list;
+
+	switch (cmd) {
+	case COUNTER_CLEAR_WATCHES_IOCTL:
+		raw_spin_lock_irqsave(events_lock, flags);
+		counter_events_list_free(events_list);
+		raw_spin_unlock_irqrestore(events_lock, flags);
+		counter_events_list_free(next_events_list);

I think this ioctl is doing too much. If we have to use it for both stopping events and clearing the list accumulated by COUNTER_SET_WATCH_IOCTL, then we have a race condition of no events after clearing watches during the time we are adding new ones and until we load the new ones.

It would probably make more sense to call this ioctl COUNTER_STOP_WATCHES_IOCTL and move counter_events_list_free( next_events_list) to the end of COUNTER_LOAD_WATCHES_IOCTL.

drivers/counter/counter-chrdev.c line 271

Quoted 3 lines

drivers/counter/counter-chrdev.c new file +3 -0

+		break;
+	case COUNTER_SET_WATCH_IOCTL:
+		return counter_set_watch(counter, arg);

Would it make more sense to call this COUNTER_ADD_WATCH_IOCTL since it adds a watch to the list that will be loaded/enabled later?

drivers/counter/counter-chrdev.c line 276

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+	case COUNTER_LOAD_WATCHES_IOCTL:
+		raw_spin_lock_irqsave(events_lock, flags);
+		counter_events_list_free(events_list);
+		list_replace_init(next_events_list, events_list);
+		raw_spin_unlock_irqrestore(events_lock, flags);

For the eQEP driver, we will need a callback here to configure interrupts for the events. Likewise a callback would be needed here (for the case when we are replacing already loaded watches) and in COUNTER_STOP_WATCHES_IOCTL to unconfigure them.

Quoted 21 lines

drivers/counter/counter-chrdev.c new file +21 -0

+		break;
+	default:
+		return -ENOIOCTLCMD;
+	}
+
+	return 0;
+}
+
+static int counter_chrdev_open(struct inode *inode, struct file *filp)
+{
+	struct counter_device *const counter = container_of(inode->i_cdev,
+							    typeof(*counter),
+							    chrdev);
+
+	get_device(&counter->dev);
+	filp->private_data = counter;
+
+	return nonseekable_open(inode, filp);
+}
+
+static int counter_chrdev_release(struct inode *inode, struct file *filp)

drivers/counter/counter-chrdev.c line 302

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+{
+	struct counter_device *const counter = filp->private_data;
+	unsigned long flags;
+
+	put_device(&counter->dev);

put_device() should be at the end of the function in case it is the last reference.

Quoted 53 lines

drivers/counter/counter-chrdev.c new file +52 -0

+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+	counter_events_list_free(&counter->events_list);
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+	counter_events_list_free(&counter->next_events_list);
+
+	return 0;
+}
+
 
+int counter_push_event(struct counter_device *const counter, const u8 event,
+		       const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+	int err;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->events_list, l)
+		if (event_node->event == event &&
+		    event_node->channel == channel)
+			break;
+
+	/* If event is not in the list */
+	if (&event_node->l == &counter->events_list)
+		goto exit_early;
+
+	/* Read and queue relevant comp for userspace */
+	list_for_each_entry(comp_node, &event_node->comp_list, l) {
+		err = counter_get_data(counter, comp_node, &ev.value_u8);
+		if (err)
+			goto err_counter_get_data;
+
+		ev.watch.component = comp_node->component;
+
+		copied += kfifo_put(&counter->events, ev);
+	}
+
+	if (copied)
+		wake_up_poll(&counter->events_wait, EPOLLIN);
+
+exit_early:
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+

drivers/counter/counter-chrdev.c line 449

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+	return 0;
+
+err_counter_get_data:
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+	return err;

This seems slightly redundant. Could just initialize err to 0 and combine the two labels.

Quoted 2 lines

drivers/counter/counter-chrdev.c new file +2 -0

+}
+EXPORT_SYMBOL_GPL(counter_push_event);

drivers/counter/counter-sysfs.c

Quoted 4 lines

drivers/counter/counter-sysfs.c +0 -0

index e66ed99dd5ea..cefef61f170d 100644

Not sure why sysfs changes are in the chrdev patch. Are these changes related somehow?

Quoted 11 lines

include/uapi/linux/counter.h new file +5 -0

new file mode 100644
index 000000000000..ad9a8686b2b0
@@ -0,0 +1,99 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Userspace ABI for Counter character devices
+ * Copyright (C) 2020 William Breathitt Gray
+ */

include/uapi/linux/counter.h line 10

Quoted 5 lines

include/uapi/linux/counter.h new file +5 -0

+#ifndef _UAPI_COUNTER_H_
+#define _UAPI_COUNTER_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>

It would be very helpful to have documentation comments for all of the defines in this file.

Quoted 7 lines

include/uapi/linux/counter.h new file +7 -0

+
+#define COUNTER_SCOPE_DEVICE 0
+#define COUNTER_SCOPE_SIGNAL 1
+#define COUNTER_SCOPE_COUNT 2
+
+#define COUNTER_COMPONENT_SIGNAL 0
+#define COUNTER_COMPONENT_COUNT 1

include/uapi/linux/counter.h line 20

Quoted 3 lines

include/uapi/linux/counter.h new file +3 -0

+#define COUNTER_COMPONENT_FUNCTION 2
+#define COUNTER_COMPONENT_SYNAPSE_ACTION 3
+#define COUNTER_COMPONENT_EXTENSION 4

There are probably some cases where we will want to just have an event without reading a component value, so we could use something like COUNTER_SCOPE_NONE and COUNTER_COMPONENT_NONE here.

Quoted 13 lines

include/uapi/linux/counter.h new file +13 -0

+
+/**
+ * struct counter_component - Counter component identification
+ * @scope: component scope (Device, Count, or Signal)
+ * @parent: parent component identification number
+ * @type: component type (Count, extension, etc.)
+ * @id: component identification number
+ */
+struct counter_component {
+	__u8 scope;
+	__u64 parent;
+	__u8 type;
+	__u64 id;

include/uapi/linux/counter.h line 34

Quoted 1 line

include/uapi/linux/counter.h new file +1 -0

+};

This will have alignment issues, e.g. when 64-bit kernel is used with a 32-bit userspace. It looks like there is a __aligned_u64 type to help with this. But, unless we expect more that 4 billion counter devices, there doesn't seem to be a reason for parent and id to be 64-bit.

include/uapi/linux/counter.h line 38

Quoted 4 lines

include/uapi/linux/counter.h new file +4 -0

+
+#define COUNTER_EVENT_OVERFLOW 0
+#define COUNTER_EVENT_UNDERFLOW 1
+#define COUNTER_EVENT_OVERFLOW_UNDERFLOW 2

Would it make sense to just have individual overflow and underflow events? For example, the Carry-Borrow interrupt on 104-quad-8 could just call counter_push_event() twice.

include/uapi/linux/counter.h line 45

Quoted 7 lines

include/uapi/linux/counter.h new file +7 -0

+#define COUNTER_EVENT_THRESHOLD 3
+#define COUNTER_EVENT_INDEX 4
+
+/**
+ * struct counter_watch - Counter component watch configuration
+ * @event: event that triggers
+ * @channel: event channel

How is channel intended to be used? (The device I am working with I assume would ignore the channel since it is just a single counter.)

include/uapi/linux/counter.h line 52

Quoted 7 lines

include/uapi/linux/counter.h new file +7 -0

+ * @component: component to watch when event triggers
+ */
+struct counter_watch {
+	__u8 event;
+	__u8 channel;
+	struct counter_component component;
+};

To get the most compact layout, usually fields are ordered largest to smallest.

Quoted 14 lines

include/uapi/linux/counter.h new file +14 -0

+
+#define COUNTER_CLEAR_WATCHES_IOCTL _IO(0x3E, 0x00)
+#define COUNTER_SET_WATCH_IOCTL _IOW(0x3E, 0x01, struct counter_watch)
+#define COUNTER_LOAD_WATCHES_IOCTL _IO(0x3E, 0x02)
+
+/**
+ * struct counter_event - Counter event data
+ * @timestamp: best estimate of time of event occurrence, in nanoseconds
+ * @watch: component watch configuration
+ * @value_u8: component value as __u8 data type
+ * @value_u64: component value as __u64 data type
+ */
+struct counter_event {
+	__u64 timestamp;

include/uapi/linux/counter.h line 72

Quoted 6 lines

include/uapi/linux/counter.h new file +6 -0

+	struct counter_watch watch;
+	union {
+		__u8 value_u8;
+		__u64 value_u64;
+	};
+};

Should probably use __aligned_u64 here too.

Quoted 18 lines

include/uapi/linux/counter.h new file +17 -0

+
+#define COUNTER_COUNT_DIRECTION_FORWARD 0
+#define COUNTER_COUNT_DIRECTION_BACKWARD 1
+
+#define COUNTER_COUNT_MODE_NORMAL 0
+#define COUNTER_COUNT_MODE_RANGE_LIMIT 1
+#define COUNTER_COUNT_MODE_NON_RECYCLE 2
+#define COUNTER_COUNT_MODE_MODULO_N 3
+
+#define COUNTER_FUNCTION_INCREASE 0
+#define COUNTER_FUNCTION_DECREASE 1
+#define COUNTER_FUNCTION_PULSE_DIRECTION 2
+#define COUNTER_FUNCTION_QUADRATURE_X1_A 3
+#define COUNTER_FUNCTION_QUADRATURE_X1_B 4
+#define COUNTER_FUNCTION_QUADRATURE_X2_A 5
+#define COUNTER_FUNCTION_QUADRATURE_X2_B 6
+#define COUNTER_FUNCTION_QUADRATURE_X4 7

include/uapi/linux/counter.h line 99

Quoted 10 lines

include/uapi/linux/counter.h new file +10 -0

+
+#define COUNTER_SIGNAL_LEVEL_LOW 0
+#define COUNTER_SIGNAL_LEVEL_HIGH 1
+
+#define COUNTER_SYNAPSE_ACTION_NONE 0
+#define COUNTER_SYNAPSE_ACTION_RISING_EDGE 1
+#define COUNTER_SYNAPSE_ACTION_FALLING_EDGE 2
+#define COUNTER_SYNAPSE_ACTION_BOTH_EDGES 3
+
+#endif /* _UAPI_COUNTER_H_ */

Overall, I think we are getting close. I've started adding events to the TI eQEP driver. You can find the code at [1]. I still have a bit of work to do to add the timer and edge capture events.

[1]: https://github.com/dlech/linux/tree/bone-counter

Quoted 23 lines

Quoted 6 lines

drivers/counter/counter-chrdev.c new file +5 -0

+static long counter_chrdev_ioctl(struct file *filp, unsigned int cmd,
+				 unsigned long arg)
+{
+	struct counter_device *const counter = filp->private_data;
+	raw_spinlock_t *const events_lock = &counter->events_lock;

drivers/counter/counter-chrdev.c line 268

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+	unsigned long flags;
+	struct list_head *const events_list = &counter->events_list;
+	struct list_head *const next_events_list = &counter->next_events_list;
+
+	switch (cmd) {
+	case COUNTER_CLEAR_WATCHES_IOCTL:
+		raw_spin_lock_irqsave(events_lock, flags);
+		counter_events_list_free(events_list);
+		raw_spin_unlock_irqrestore(events_lock, flags);
+		counter_events_list_free(next_events_list);

I think this ioctl is doing too much. If we have to use it for both stopping events and clearing the list accumulated by COUNTER_SET_WATCH_IOCTL, then we have a race condition of no events after clearing watches during the time we are adding new ones and until we load the new ones.

Quoted 3 lines

It would probably make more sense to call this ioctl COUNTER_STOP_WATCHES_IOCTL and move counter_events_list_free( next_events_list) to the end of COUNTER_LOAD_WATCHES_IOCTL.

I don't think we will necessarily have a race condition here. COUNTER_CLEAR_WATCHES_IOCTL is intended to just clear the watches; e.g. bring us back to a clear state when some sort of job has completely finished and the user is no longer going to watch events for a while (maybe they're adjusting the conveyor for the next job or some similar operation).

I think the scenario you're concerned about is when you need to swap watches in the middle of a job without losing events. In this case, you wouldn't need to use COUNTER_CLEAR_WATCHES_IOCTL at all. Instead, you would just set up the watches via COUNTER_SET_WATCH_IOCTL, and then use COUNTER_LOAD_WATCHES_IOCTL to perform the swap; after COUNTER_LOAD_WATCHES_IOCTL completes, next_events_list is empty (thanks to list_replace_init()) and you're ready for the next set of watches.

Quoted 10 lines

drivers/counter/counter-chrdev.c line 302

Quoted 7 lines

drivers/counter/counter-chrdev.c new file +7 -0

+
+static int counter_chrdev_release(struct inode *inode, struct file *filp)
+{
+	struct counter_device *const counter = filp->private_data;
+	unsigned long flags;
+
+	put_device(&counter->dev);

put_device() should be at the end of the function in case it is the last reference.

put_device() shouldn't affect the counter_device events members, so I don't think there's a difference in this case if it's called at the beginning or end of the counter_chrdev_release function.

Quoted 4 lines

Quoted 2 lines

(quoted diff) +2 -0

+}
+EXPORT_SYMBOL_GPL(counter_push_event);

Quoted 8 lines

drivers/counter/counter-sysfs.c

Quoted 4 lines

drivers/counter/counter-sysfs.c +0 -0

index e66ed99dd5ea..cefef61f170d 100644

Not sure why sysfs changes are in the chrdev patch. Are these changes related somehow?

Sorry, I forgot to explain this in the cover letter. The changes here are only useful for the character device interface. These changes introduce the extensionZ_name and extensionZ_width sysfs attributes.

In the character device interface, extensions are selected by their id number, and the value returned depends on the type of data. The new sysfs attributes introduced here allow users to match the id of an extension with its name, as well as the bit width of the value returned so that the user knows whether to use the value_u8 or value_u64 union member in struct counter_event.

Quoted 11 lines

Quoted 10 lines

drivers/counter/counter-chrdev.c line 302

Quoted 7 lines

drivers/counter/counter-chrdev.c new file +7 -0

+
+static int counter_chrdev_release(struct inode *inode, struct file *filp)
+{
+	struct counter_device *const counter = filp->private_data;
+	unsigned long flags;
+
+	put_device(&counter->dev);

put_device() should be at the end of the function in case it is the last reference.

Quoted 4 lines

put_device() shouldn't affect the counter_device events members, so I don't think there's a difference in this case if it's called at the beginning or end of the counter_chrdev_release function.

It isn't possible the some memory allocated with devm_kalloc() could be be referenced after calling put_device() now or in the future?

Quoted 13 lines

Quoted 8 lines

drivers/counter/counter-sysfs.c

Quoted 4 lines

drivers/counter/counter-sysfs.c +0 -0

index e66ed99dd5ea..cefef61f170d 100644

Not sure why sysfs changes are in the chrdev patch. Are these changes related somehow?

Sorry, I forgot to explain this in the cover letter. The changes here are only useful for the character device interface. These changes introduce the extensionZ_name and extensionZ_width sysfs attributes.

Quoted 7 lines

In the character device interface, extensions are selected by their id number, and the value returned depends on the type of data. The new sysfs attributes introduced here allow users to match the id of an extension with its name, as well as the bit width of the value returned so that the user knows whether to use the value_u8 or value_u64 union member in struct counter_event.

Are we sure that all value types will always be CPU-endian unsigned integers? Or should we make an enum to describe the data type instead of just the width?

Quoted 22 lines

Quoted 14 lines

Quoted 9 lines

drivers/counter/counter-sysfs.c

Quoted 5 lines

drivers/counter/counter-sysfs.c +0 -0

index e66ed99dd5ea..cefef61f170d 100644

Not sure why sysfs changes are in the chrdev patch. Are these changes related somehow?

Sorry, I forgot to explain this in the cover letter. The changes here are only useful for the character device interface. These changes introduce the extensionZ_name and extensionZ_width sysfs attributes.

Quoted 7 lines

In the character device interface, extensions are selected by their id number, and the value returned depends on the type of data. The new sysfs attributes introduced here allow users to match the id of an extension with its name, as well as the bit width of the value returned so that the user knows whether to use the value_u8 or value_u64 union member in struct counter_event.

Quoted 3 lines

Are we sure that all value types will always be CPU-endian unsigned integers? Or should we make an enum to describe the data type instead of just the width?

It should be safe to assume that the character device interface will only ever return CPU-endian unsigned integers. The device driver should handle the conversion of any strange endianness from the device before the character device interface, while userspace is the one responsible for interpreting the meaning of count in the context of the application.

Let's create a scenario for the sake of example. Suppose we want to use a counter device to track the vertical position of a component moved by a linear actuator. The operator considers some vertical position as the horizon, where anything above would be a positive position and anything below a negative position. The counter device stores its count in big-endian format; but the system CPU expects little-endian.

The flow of data for this scenario would look like the following (where BE = big-endian, LE = little-endian):

+----------+         +---------------+          +--------+
| Raw data | - BE -> | Device driver | -> LE -> | chrdev | - u64 ->
+----------+         +---------------+          +--------+

At this point, the userspace application would read the unsigned integer from the character device and determine how to interpret the position -- whether the count be converted to a signed value to represent a negative physical position.

Whether or not a position should be considered negative is dependent on the user application and context. Because the character device does not know the context of the user application, it should only provide unsigned integers in order to ensure a standard interface for counter devices; userspace will be responsible for interpreting those counts to something meaningful for the context of their applications.

William Breathitt Gray

drivers/counter/counter-chrdev.c new file +31 -0

new file mode 100644
index 000000000000..2be3846e4105
 
 
+/**
+ * counter_push_event - queue event for userspace reading
+ * @counter:	pointer to Counter structure
+ * @event:	triggered event
+ * @channel:	event channel
+ *
+ * Note: If no one is watching for the respective event, it is silently
+ * discarded.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int counter_push_event(struct counter_device *const counter, const u8 event,
+		       const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+	int err;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->events_list, l)
+		if (event_node->event == event &&

drivers/counter/counter-chrdev.c new file +20 -0

+		if (err)
+			goto err_counter_get_data;
+
+		ev.watch.component = comp_node->component;
+
+		copied += kfifo_put(&counter->events, ev);
+	}
+
+	if (copied)
+		wake_up_poll(&counter->events_wait, EPOLLIN);
+
+exit_early:
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+
+	return 0;
+
+err_counter_get_data:
+	raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+	return err;
+}

Quoted 38 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +31 -0

new file mode 100644
index 000000000000..2be3846e4105
 
 
+/**
+ * counter_push_event - queue event for userspace reading
+ * @counter:	pointer to Counter structure
+ * @event:	triggered event
+ * @channel:	event channel
+ *
+ * Note: If no one is watching for the respective event, it is silently
+ * discarded.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int counter_push_event(struct counter_device *const counter, const u8 event,
+		       const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+	int err;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->events_list, l)
+		if (event_node->event == event &&

drivers/counter/counter-chrdev.c line 430

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+		    event_node->channel == channel)
+			break;
+
+	/* If event is not in the list */
+	if (&event_node->l == &counter->events_list)
+		goto exit_early;
+
+	/* Read and queue relevant comp for userspace */
+	list_for_each_entry(comp_node, &event_node->comp_list, l) {
+		err = counter_get_data(counter, comp_node, &ev.value_u8);

Currently all counter devices are memory mapped devices so calling counter_get_data() here with interrupts disabled is probably OK, but if any counter drivers are added that use I2C/SPI/etc. that will take a long time to read, it would cause problems leaving interrupts disabled here.

Brainstorming: Would it make sense to separate the event from the component value being read? As I mentioned in one of my previous reviews, I think there are some cases where we would just want to know when an event happened and not read any additional data anyway. In the case of a slow communication bus, this would also let us queue the event in the kfifo and notify poll right away and then defer the reads in a workqueue for later.

Quoted 56 lines · David Lechner

Quoted 38 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +31 -0

new file mode 100644
index 000000000000..2be3846e4105
 
 
+/**
+ * counter_push_event - queue event for userspace reading
+ * @counter:	pointer to Counter structure
+ * @event:	triggered event
+ * @channel:	event channel
+ *
+ * Note: If no one is watching for the respective event, it is silently
+ * discarded.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int counter_push_event(struct counter_device *const counter, const u8 event,
+		       const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+	int err;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	raw_spin_lock_irqsave(&counter->events_lock, flags);
+
+	/* Search for event in the list */
+	list_for_each_entry(event_node, &counter->events_list, l)
+		if (event_node->event == event &&

drivers/counter/counter-chrdev.c line 430

Quoted 10 lines

drivers/counter/counter-chrdev.c new file +10 -0

+		    event_node->channel == channel)
+			break;
+
+	/* If event is not in the list */
+	if (&event_node->l == &counter->events_list)
+		goto exit_early;
+
+	/* Read and queue relevant comp for userspace */
+	list_for_each_entry(comp_node, &event_node->comp_list, l) {
+		err = counter_get_data(counter, comp_node, &ev.value_u8);

Currently all counter devices are memory mapped devices so calling counter_get_data() here with interrupts disabled is probably OK, but if any counter drivers are added that use I2C/SPI/etc. that will take a long time to read, it would cause problems leaving interrupts disabled here.

Quoted 7 lines

Brainstorming: Would it make sense to separate the event from the component value being read? As I mentioned in one of my previous reviews, I think there are some cases where we would just want to know when an event happened and not read any additional data anyway. In the case of a slow communication bus, this would also let us queue the event in the kfifo and notify poll right away and then defer the reads in a workqueue for later.

I don't see any problems with reporting just an event without any component value attached (e.g. userspace could handle the component reads via sysfs at a later point). We would just need a way to inform userspace that the struct counter_component in the struct counter_watch returned should be ignored.

Perhaps we can add an additional member to struct counter_watch indicating whether it's an empty watch; or alternatively, add a new component scope define to differentiate between an actual component and an empty one (e.g. COUNTER_SCOPE_EVENT). What do you think?

William Breathitt Gray

drivers/counter/counter-chrdev.c new file +21 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}

Quoted 26 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +26 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}
+
+		raw_spin_lock_irqsave(&counter->events_lock, flags);
+		err = kfifo_to_user(&counter->events, buf, len, &copied);
+		raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+		if (err)

drivers/counter/counter-chrdev.c line 71

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+			return err;
+	} while (!copied);
+
+	return copied;
+}

All other uses of kfifo_to_user() I saw use a mutex instead of spin lock. I don't see a reason for disabling interrupts here.

Quoted 27 lines · David Lechner

Quoted 26 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +26 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}
+
+		raw_spin_lock_irqsave(&counter->events_lock, flags);
+		err = kfifo_to_user(&counter->events, buf, len, &copied);
+		raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+		if (err)

Quoted 8 lines

drivers/counter/counter-chrdev.c line 71

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+			return err;
+	} while (!copied);
+
+	return copied;
+}

All other uses of kfifo_to_user() I saw use a mutex instead of spin lock. I don't see a reason for disabling interrupts here.

The Counter character device interface is special in this case because counter->events could be accessed from an interrupt context. This is possible if counter_push_event() is called for an interrupt (as is the case for the 104_quad_8 driver). In this case, we can't use mutex because we can't sleep in an interrupt context, so our only option is to use spin lock.

Quoted 37 lines · William Breathitt Gray

Quoted 27 lines · David Lechner

Quoted 26 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +26 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}
+
+		raw_spin_lock_irqsave(&counter->events_lock, flags);
+		err = kfifo_to_user(&counter->events, buf, len, &copied);
+		raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+		if (err)

Quoted 8 lines

drivers/counter/counter-chrdev.c line 71

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+			return err;
+	} while (!copied);
+
+	return copied;
+}

All other uses of kfifo_to_user() I saw use a mutex instead of spin lock. I don't see a reason for disabling interrupts here.

Quoted 7 lines

The Counter character device interface is special in this case because counter->events could be accessed from an interrupt context. This is possible if counter_push_event() is called for an interrupt (as is the case for the 104_quad_8 driver). In this case, we can't use mutex because we can't sleep in an interrupt context, so our only option is to use spin lock.

The way I understand it, locking is only needed for concurrent readers and locking between reader and writer is not needed.

Quoted 47 lines · David Lechner

Quoted 37 lines · William Breathitt Gray

Quoted 27 lines · David Lechner

Quoted 26 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +26 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}
+
+		raw_spin_lock_irqsave(&counter->events_lock, flags);
+		err = kfifo_to_user(&counter->events, buf, len, &copied);
+		raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+		if (err)

Quoted 8 lines

drivers/counter/counter-chrdev.c line 71

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+			return err;
+	} while (!copied);
+
+	return copied;
+}

All other uses of kfifo_to_user() I saw use a mutex instead of spin lock. I don't see a reason for disabling interrupts here.

Quoted 7 lines

The Counter character device interface is special in this case because counter->events could be accessed from an interrupt context. This is possible if counter_push_event() is called for an interrupt (as is the case for the 104_quad_8 driver). In this case, we can't use mutex because we can't sleep in an interrupt context, so our only option is to use spin lock.

Quoted 2 lines

The way I understand it, locking is only needed for concurrent readers and locking between reader and writer is not needed.

You're right, it does say in the kfifo.h comments that with only one concurrent reader and one current write, we don't need extra locking to use these macros. Because we only have one kfifo_to_user() operating on counter->events, does that mean we don't need locking at all here for the counter_chrdev_read() function?

William Breathitt Gray

Quoted 57 lines · William Breathitt Gray

Quoted 47 lines · David Lechner

Quoted 37 lines · William Breathitt Gray

Quoted 27 lines · David Lechner

Quoted 26 lines · William Breathitt Gray

drivers/counter/counter-chrdev.c new file +26 -0

+static ssize_t counter_chrdev_read(struct file *filp, char __user *buf,
+				   size_t len, loff_t *f_ps)
+{
+	struct counter_device *const counter = filp->private_data;
+	int err;
+	unsigned long flags;
+	unsigned int copied;
+
+	if (len < sizeof(struct counter_event))
+		return -EINVAL;
+
+	do {
+		if (kfifo_is_empty(&counter->events)) {
+			if (filp->f_flags & O_NONBLOCK)
+				return -EAGAIN;
+
+			err = wait_event_interruptible(counter->events_wait,
+					!kfifo_is_empty(&counter->events));
+			if (err)
+				return err;
+		}
+
+		raw_spin_lock_irqsave(&counter->events_lock, flags);
+		err = kfifo_to_user(&counter->events, buf, len, &copied);
+		raw_spin_unlock_irqrestore(&counter->events_lock, flags);
+		if (err)

Quoted 8 lines

drivers/counter/counter-chrdev.c line 71

Quoted 5 lines

drivers/counter/counter-chrdev.c new file +5 -0

+			return err;
+	} while (!copied);
+
+	return copied;
+}

All other uses of kfifo_to_user() I saw use a mutex instead of spin lock. I don't see a reason for disabling interrupts here.

Quoted 7 lines

The Counter character device interface is special in this case because counter->events could be accessed from an interrupt context. This is possible if counter_push_event() is called for an interrupt (as is the case for the 104_quad_8 driver). In this case, we can't use mutex because we can't sleep in an interrupt context, so our only option is to use spin lock.

Quoted 2 lines

The way I understand it, locking is only needed for concurrent readers and locking between reader and writer is not needed.

You're right, it does say in the kfifo.h comments that with only one concurrent reader and one current write, we don't need extra locking to use these macros. Because we only have one kfifo_to_user() operating on counter->events, does that mean we don't need locking at all here for the counter_chrdev_read() function?

Quoted 2 lines

William Breathitt Gray

Even if we have the policy that only one file handle to the chrdev can be open at a time, it is still possible that the it could be read from multiple threads. So it I think it makes sense to keep it just to be safe.

+ read(pfd.fd, event_data, sizeof(event_data));

Hi!

Documentation/driver-api/generic-counter.rst and vice versa. · line 607

Quoted 13 lines

Documentation/driver-api/generic-counter.rst +13 -0

+        int main(void)
+        {
+                struct pollfd pfd = { .events = POLLIN };
+                struct counter_event event_data[2];
+
+                pfd.fd = open("/dev/counter0", O_RDWR);
+
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches);
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches + 1);
+                ioctl(pfd.fd, COUNTER_LOAD_WATCHES_IOCTL);
+
+                for (;;) {
+                        poll(&pfd, 1, -1);

Why do poll, when you are doing blocking read?

Quoted 1 line

+ read(pfd.fd, event_data, sizeof(event_data));

Does your new chrdev always guarantee returning complete buffer?

If so, should it behave like that?

Best regards,
Pavel

Signature · 2 lines

(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Quoted 18 lines · Pavel Machek

Hi!

Documentation/driver-api/generic-counter.rst and vice versa. · line 607

Quoted 13 lines

Documentation/driver-api/generic-counter.rst +13 -0

+        int main(void)
+        {
+                struct pollfd pfd = { .events = POLLIN };
+                struct counter_event event_data[2];
+
+                pfd.fd = open("/dev/counter0", O_RDWR);
+
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches);
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches + 1);
+                ioctl(pfd.fd, COUNTER_LOAD_WATCHES_IOCTL);
+
+                for (;;) {
+                        poll(&pfd, 1, -1);

Why do poll, when you are doing blocking read?

Quoted 11 lines

Quoted 1 line

+ read(pfd.fd, event_data, sizeof(event_data));

Does your new chrdev always guarantee returning complete buffer?

If so, should it behave like that?

Best regards,
Pavel

Signature · 2 lines

(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

I suppose you're right: a poll() should be redundant now with this version of the character device implementation because buffers will always return complete; so a blocking read() should achieve the same behavior that a poll() with read() would.

I'll give some more time for additional feedback to come in for this version of the patchset, and then likely remove support for poll() in the v6 submission.

William Breathitt Gray

Quoted 40 lines · William Breathitt Gray

Quoted 18 lines · Pavel Machek

Hi!

Documentation/driver-api/generic-counter.rst and vice versa. · line 607

Quoted 13 lines

Documentation/driver-api/generic-counter.rst +13 -0

+        int main(void)
+        {
+                struct pollfd pfd = { .events = POLLIN };
+                struct counter_event event_data[2];
+
+                pfd.fd = open("/dev/counter0", O_RDWR);
+
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches);
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches + 1);
+                ioctl(pfd.fd, COUNTER_LOAD_WATCHES_IOCTL);
+
+                for (;;) {
+                        poll(&pfd, 1, -1);

Why do poll, when you are doing blocking read?

Quoted 11 lines

Quoted 1 line

+ read(pfd.fd, event_data, sizeof(event_data));

Does your new chrdev always guarantee returning complete buffer?

If so, should it behave like that?

Best regards,
Pavel

Signature · 2 lines

(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

I suppose you're right: a poll() should be redundant now with this version of the character device implementation because buffers will always return complete; so a blocking read() should achieve the same behavior that a poll() with read() would.

I'll give some more time for additional feedback to come in for this version of the patchset, and then likely remove support for poll() in the v6 submission.

Quoted 2 lines

William Breathitt Gray

I hope that you mean that you will just remove it from the example and not from the chardev. Otherwise it won't be possible to integrate this with an event loop.

Quoted 41 lines · David Lechner

Quoted 40 lines · William Breathitt Gray

Quoted 18 lines · Pavel Machek

Hi!

Documentation/driver-api/generic-counter.rst and vice versa. · line 607

Quoted 13 lines

Documentation/driver-api/generic-counter.rst +13 -0

+        int main(void)
+        {
+                struct pollfd pfd = { .events = POLLIN };
+                struct counter_event event_data[2];
+
+                pfd.fd = open("/dev/counter0", O_RDWR);
+
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches);
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches + 1);
+                ioctl(pfd.fd, COUNTER_LOAD_WATCHES_IOCTL);
+
+                for (;;) {
+                        poll(&pfd, 1, -1);

Why do poll, when you are doing blocking read?

Quoted 11 lines

Quoted 1 line

+ read(pfd.fd, event_data, sizeof(event_data));

Does your new chrdev always guarantee returning complete buffer?

If so, should it behave like that?

Best regards,
Pavel

Signature · 2 lines

(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

I suppose you're right: a poll() should be redundant now with this version of the character device implementation because buffers will always return complete; so a blocking read() should achieve the same behavior that a poll() with read() would.

I'll give some more time for additional feedback to come in for this version of the patchset, and then likely remove support for poll() in the v6 submission.

Quoted 6 lines

Quoted 2 lines

William Breathitt Gray

I hope that you mean that you will just remove it from the example and not from the chardev. Otherwise it won't be possible to integrate this with an event loop.

Would you elaborate a bit further on this? My thought process is that because users must set the Counter Events they want to watch, and only those Counter Events show up in the character device node, a blocking read() would effectively behave the same as poll() with read(); if none of the Counter Events occur, the read() just blocks until one does, thus making the use of a poll() call redundant.

William Breathitt Gray

Quoted 49 lines · William Breathitt Gray

Quoted 41 lines · David Lechner

Quoted 40 lines · William Breathitt Gray

Quoted 18 lines · Pavel Machek

Hi!

Documentation/driver-api/generic-counter.rst and vice versa. · line 607

Quoted 13 lines

Documentation/driver-api/generic-counter.rst +13 -0

+        int main(void)
+        {
+                struct pollfd pfd = { .events = POLLIN };
+                struct counter_event event_data[2];
+
+                pfd.fd = open("/dev/counter0", O_RDWR);
+
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches);
+                ioctl(pfd.fd, COUNTER_SET_WATCH_IOCTL, watches + 1);
+                ioctl(pfd.fd, COUNTER_LOAD_WATCHES_IOCTL);
+
+                for (;;) {
+                        poll(&pfd, 1, -1);

Why do poll, when you are doing blocking read?

Quoted 11 lines

Quoted 1 line

+ read(pfd.fd, event_data, sizeof(event_data));

Does your new chrdev always guarantee returning complete buffer?

If so, should it behave like that?

Best regards,
Pavel

Signature · 2 lines

(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

I suppose you're right: a poll() should be redundant now with this version of the character device implementation because buffers will always return complete; so a blocking read() should achieve the same behavior that a poll() with read() would.

I'll give some more time for additional feedback to come in for this version of the patchset, and then likely remove support for poll() in the v6 submission.

Quoted 6 lines

Quoted 2 lines

William Breathitt Gray

I hope that you mean that you will just remove it from the example and not from the chardev. Otherwise it won't be possible to integrate this with an event loop.

Quoted 9 lines

Would you elaborate a bit further on this? My thought process is that because users must set the Counter Events they want to watch, and only those Counter Events show up in the character device node, a blocking read() would effectively behave the same as poll() with read(); if none of the Counter Events occur, the read() just blocks until one does, thus making the use of a poll() call redundant.

William Breathitt Gray