michaelh/zephyr
1
0
Fork 0
Code Releases Activity

syscalls: remove policy from handler checks

Browse source 
The various macros to do checks in system call handlers all
implictly would generate a kernel oops if a check failed.
This is undesirable for a few reasons:

* System call handlers that acquire resources in the handler
  have no good recourse for cleanup if a check fails.
* In some cases we may want to propagate a return value back
  to the caller instead of just killing the calling thread,
  even though the base API doesn't do these checks.

These macros now all return a value, if nonzero is returned
the check failed. K_OOPS() now wraps these calls to generate
a kernel oops.

At the moment, the policy for all APIs has not changed. They
still all oops upon a failed check/

The macros now use the Z_ notation for private APIs.

Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2018-05-04 15:57:57 -07:00 • committed by Anas Nashif
commit 8345e5ebf0
31 changed files with 365 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

32
drivers/serial/uart_handlers.c
View file

@ -8,31 +8,31 @@
#include <syscall_handler.h>
#define UART_SIMPLE(op_) \
_SYSCALL_HANDLER(uart_ ## op_, dev) { \
_SYSCALL_DRIVER_UART(dev, op_); \
Z_SYSCALL_HANDLER(uart_ ## op_, dev) { \
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, op_)); \
return _impl_uart_ ## op_((struct device *)dev); \
}
#define UART_SIMPLE_VOID(op_) \
_SYSCALL_HANDLER(uart_ ## op_, dev) { \
_SYSCALL_DRIVER_UART(dev, op_); \
Z_SYSCALL_HANDLER(uart_ ## op_, dev) { \
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, op_)); \
_impl_uart_ ## op_((struct device *)dev); \
return 0; \
}
UART_SIMPLE(err_check)
_SYSCALL_HANDLER(uart_poll_in, dev, p_char)
Z_SYSCALL_HANDLER(uart_poll_in, dev, p_char)
{
_SYSCALL_DRIVER_UART(dev, poll_in);
_SYSCALL_MEMORY_WRITE(p_char, sizeof(unsigned char));
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_in));
Z_OOPS(Z_SYSCALL_MEMORY_WRITE(p_char, sizeof(unsigned char)));
return _impl_uart_poll_in((struct device *)dev,
(unsigned char *)p_char);
}
_SYSCALL_HANDLER(uart_poll_out, dev, out_char)
Z_SYSCALL_HANDLER(uart_poll_out, dev, out_char)
{
_SYSCALL_DRIVER_UART(dev, poll_out);
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_out));
return _impl_uart_poll_out((struct device *)dev, out_char);
}
@ -48,25 +48,25 @@ UART_SIMPLE(irq_update)
#endif /* CONFIG_UART_INTERRUPT_DRIVEN */
#ifdef CONFIG_UART_LINE_CTRL
_SYSCALL_HANDLER(uart_line_ctrl_set, dev, ctrl, val)
Z_SYSCALL_HANDLER(uart_line_ctrl_set, dev, ctrl, val)
{
_SYSCALL_DRIVER_UART(dev, line_ctrl_set);
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, line_ctrl_set));
return _impl_uart_line_ctrl_set((struct device *)dev, ctrl, val);
}
_SYSCALL_HANDLER(uart_line_ctrl_get, dev, ctrl, val);
Z_SYSCALL_HANDLER(uart_line_ctrl_get, dev, ctrl, val);
{
_SYSCALL_DRIVER_UART(dev, line_ctrl_get);
_SYSCALL_MEMORY_WRITE(val, sizeof(u32_t));
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, line_ctrl_get));
Z_OOPS(Z_SYSCALL_MEMORY_WRITE(val, sizeof(u32_t)));
return _impl_uart_line_ctrl_get((struct device *)dev, ctrl,
(u32_t *)val);
}
#endif /* CONFIG_UART_LINE_CTRL */
#ifdef CONFIG_UART_DRV_CMD
_SYSCALL_HANDLER(uart_drv_cmd, dev, cmd, p)
Z_SYSCALL_HANDLER(uart_drv_cmd, dev, cmd, p)
{
_SYSCALL_DRIVER_UART(dev, drv_cmd);
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, drv_cmd));
return _impl_uart_drv_cmd((struct device *)dev, cmd, p);
}
#endif /* CONFIG_UART_DRV_CMD */