cpu/native: add args to async_read callback

Toon Stegen · Toon Stegen · commit 7020b7c09c3d · 2016-07-07T17:40:13.000+02:00
this makes it possible to pass some generic pointer that's given back as
an argument when the callback is called.
diff --git a/cpu/native/async_read.c b/cpu/native/async_read.c
@@ -28,6 +28,7 @@
 
 static int _next_index;
 static int _fds[ASYNC_READ_NUMOF];
+static void *_args[ASYNC_READ_NUMOF];
 static native_async_read_callback_t _native_async_read_callbacks[ASYNC_READ_NUMOF];
 
 #ifdef __MACH__
@@ -55,7 +56,7 @@ static void _async_io_isr(void) {
     if (real_select(max_fd + 1, &rfds, NULL, NULL, &timeout) > 0) {
         for (int i = 0; i < _next_index; i++) {
             if (FD_ISSET(_fds[i], &rfds)) {
-                _native_async_read_callbacks[i](_fds[i]);
+                _native_async_read_callbacks[i](_fds[i], _args[i]);
             }
         }
     }
@@ -86,12 +87,13 @@ void native_async_read_continue(int fd) {
 #endif
 }
 
-void native_async_read_add_handler(int fd, native_async_read_callback_t handler) {
+void native_async_read_add_handler(int fd, void *arg, native_async_read_callback_t handler) {
     if (_next_index >= ASYNC_READ_NUMOF) {
         err(EXIT_FAILURE, "native_async_read_add_handler(): too many callbacks");
     }
 
     _fds[_next_index] = fd;
+    _args[_next_index] = arg;
     _native_async_read_callbacks[_next_index] = handler;
 
 #ifdef __MACH__
diff --git a/cpu/native/include/async_read.h b/cpu/native/include/async_read.h
@@ -32,7 +32,7 @@ extern "C" {
 /**
  * @brief   asynchronus read callback type
  */
-typedef void (*native_async_read_callback_t)(int fd);
+typedef void (*native_async_read_callback_t)(int fd, void *arg);
 
 /**
  * @brief   initialize asynchronus read system
@@ -61,10 +61,11 @@ void native_async_read_continue(int fd);
  * @brief   start monitoring of file descriptor
  *
  * @param[in] fd       The file descriptor to monitor
+ * @param[in] arg      Pointer to be passed as arguments to the callback
  * @param[in] handler  The callback function to be called when the file
  *                     descriptor is ready to read.
  */
-void native_async_read_add_handler(int fd, native_async_read_callback_t handler);
+void native_async_read_add_handler(int fd, void *arg, native_async_read_callback_t handler);
 
 #ifdef __cplusplus
 }
diff --git a/cpu/native/netdev2_tap/netdev2_tap.c b/cpu/native/netdev2_tap/netdev2_tap.c
@@ -307,8 +307,9 @@ void netdev2_tap_setup(netdev2_tap_t *dev, const netdev2_tap_params_t *params) {
     strncpy(dev->tap_name, *(params->tap_name), IFNAMSIZ);
 }
 
-static void _tap_isr(int fd) {
+static void _tap_isr(int fd, void *arg) {
     (void) fd;
+    (void) arg;
 
     netdev2_t *netdev = (netdev2_t *)&netdev2_tap;
 
@@ -393,7 +394,7 @@ static int _init(netdev2_t *netdev)
 
     /* configure signal handler for fds */
     native_async_read_setup();
-    native_async_read_add_handler(dev->tap_fd, _tap_isr);
+    native_async_read_add_handler(dev->tap_fd, NULL, _tap_isr);
 
 #ifdef MODULE_NETSTATS_L2
     memset(&netdev->stats, 0, sizeof(netstats_t));
diff --git a/cpu/native/periph/uart.c b/cpu/native/periph/uart.c
@@ -51,9 +51,10 @@ void tty_uart_setup(uart_t uart, const char *filename)
     tty_device_filenames[uart] = strndup(filename, PATH_MAX - 1);
 }
 
-static void io_signal_handler(int fd)
+static void io_signal_handler(int fd, void *arg)
 {
     uart_t uart;
+    (void) arg;
 
     for (uart = 0; uart < UART_NUMOF; uart++) {
         if (tty_fds[uart] == fd) {
@@ -151,7 +152,7 @@ int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
     uart_config[uart].arg = arg;
 
     native_async_read_setup();
-    native_async_read_add_handler(tty_fds[uart], io_signal_handler);
+    native_async_read_add_handler(tty_fds[uart], NULL, io_signal_handler);
 
     return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@`
`28`	`28`
`29`	`29`	`static int _next_index;`
`30`	`30`	`static int _fds[ASYNC_READ_NUMOF];`
	`31`	`+static void *_args[ASYNC_READ_NUMOF];`
`31`	`32`	`static native_async_read_callback_t _native_async_read_callbacks[ASYNC_READ_NUMOF];`
`32`	`33`
`33`	`34`	`#ifdef __MACH__`
`@@ -55,7 +56,7 @@ static void _async_io_isr(void) {`
`55`	`56`	`if (real_select(max_fd + 1, &rfds, NULL, NULL, &timeout) > 0) {`
`56`	`57`	`for (int i = 0; i < _next_index; i++) {`
`57`	`58`	`if (FD_ISSET(_fds[i], &rfds)) {`
`58`		`- _native_async_read_callbacks[i](_fds[i]);`
	`59`	`+ _native_async_read_callbacks[i](_fds[i], _args[i]);`
`59`	`60`	`}`
`60`	`61`	`}`
`61`	`62`	`}`
`@@ -86,12 +87,13 @@ void native_async_read_continue(int fd) {`
`86`	`87`	`#endif`
`87`	`88`	`}`
`88`	`89`
`89`		`-void native_async_read_add_handler(int fd, native_async_read_callback_t handler) {`
	`90`	`+void native_async_read_add_handler(int fd, void *arg, native_async_read_callback_t handler) {`
`90`	`91`	`if (_next_index >= ASYNC_READ_NUMOF) {`
`91`	`92`	`err(EXIT_FAILURE, "native_async_read_add_handler(): too many callbacks");`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`_fds[_next_index] = fd;`
	`96`	`+ _args[_next_index] = arg;`
`95`	`97`	`_native_async_read_callbacks[_next_index] = handler;`
`96`	`98`
`97`	`99`	`#ifdef __MACH__`
Original file line number	Diff line number	Diff line change
`@@ -51,9 +51,10 @@ void tty_uart_setup(uart_t uart, const char *filename)`
`51`	`51`	`tty_device_filenames[uart] = strndup(filename, PATH_MAX - 1);`
`52`	`52`	`}`
`53`	`53`
`54`		`-static void io_signal_handler(int fd)`
	`54`	`+static void io_signal_handler(int fd, void *arg)`
`55`	`55`	`{`
`56`	`56`	`uart_t uart;`
	`57`	`+ (void) arg;`
`57`	`58`
`58`	`59`	`for (uart = 0; uart < UART_NUMOF; uart++) {`
`59`	`60`	`if (tty_fds[uart] == fd) {`
`@@ -151,7 +152,7 @@ int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)`
`151`	`152`	`uart_config[uart].arg = arg;`
`152`	`153`
`153`	`154`	`native_async_read_setup();`
`154`		`- native_async_read_add_handler(tty_fds[uart], io_signal_handler);`
	`155`	`+ native_async_read_add_handler(tty_fds[uart], NULL, io_signal_handler);`
`155`	`156`
`156`	`157`	`return 0;`
`157`	`158`	`}`