syscalls: remove policy from handler checks
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>
diff --git a/drivers/adc/adc_handlers.c b/drivers/adc/adc_handlers.c
index 79f7d4c..b7051b9 100644
--- a/drivers/adc/adc_handlers.c
+++ b/drivers/adc/adc_handlers.c
@@ -7,34 +7,36 @@
#include <adc.h>
#include <syscall_handler.h>
-_SYSCALL_HANDLER(adc_enable, dev)
+Z_SYSCALL_HANDLER(adc_enable, dev)
{
- _SYSCALL_DRIVER_ADC(dev, enable);
+ Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, enable));
_impl_adc_enable((struct device *)dev);
return 0;
}
-_SYSCALL_HANDLER(adc_disable, dev)
+Z_SYSCALL_HANDLER(adc_disable, dev)
{
- _SYSCALL_DRIVER_ADC(dev, disable);
+ Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, disable));
_impl_adc_disable((struct device *)dev);
return 0;
}
-_SYSCALL_HANDLER(adc_read, dev, seq_table_p)
+Z_SYSCALL_HANDLER(adc_read, dev, seq_table_p)
{
struct adc_seq_entry *entry;
struct adc_seq_table *seq_table = (struct adc_seq_table *)seq_table_p;
int i;
- _SYSCALL_DRIVER_ADC(dev, read);
- _SYSCALL_MEMORY_READ(seq_table, sizeof(struct adc_seq_table));
- _SYSCALL_MEMORY_ARRAY_READ(seq_table->entries, seq_table->num_entries,
- sizeof(struct adc_seq_entry));
+ Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, read));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(seq_table, sizeof(struct adc_seq_table)));
+ Z_OOPS(Z_SYSCALL_MEMORY_ARRAY_READ(seq_table->entries,
+ seq_table->num_entries,
+ sizeof(struct adc_seq_entry)));
for (entry = seq_table->entries, i = 0; i < seq_table->num_entries;
i++, entry++) {
- _SYSCALL_MEMORY_WRITE(entry->buffer, entry->buffer_length);
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(entry->buffer,
+ entry->buffer_length));
}
return _impl_adc_read((struct device *)dev, seq_table);
diff --git a/drivers/aio/aio_comparator_handlers.c b/drivers/aio/aio_comparator_handlers.c
index c5e7aef..8026b7b 100644
--- a/drivers/aio/aio_comparator_handlers.c
+++ b/drivers/aio/aio_comparator_handlers.c
@@ -7,14 +7,14 @@
#include <syscall_handler.h>
#include <aio_comparator.h>
-_SYSCALL_HANDLER(aio_cmp_disable, dev, index)
+Z_SYSCALL_HANDLER(aio_cmp_disable, dev, index)
{
- _SYSCALL_DRIVER_AIO_CMP(dev, disable);
+ Z_OOPS(Z_SYSCALL_DRIVER_AIO_CMP(dev, disable));
return _impl_aio_cmp_disable((struct device *)dev, index);
}
-_SYSCALL_HANDLER(aio_cmp_get_pending_int, dev)
+Z_SYSCALL_HANDLER(aio_cmp_get_pending_int, dev)
{
- _SYSCALL_DRIVER_AIO_CMP(dev, get_pending_int);
+ Z_OOPS(Z_SYSCALL_DRIVER_AIO_CMP(dev, get_pending_int));
return _impl_aio_get_pending_int((struct device *)dev, index);
}
diff --git a/drivers/counter/counter_handlers.c b/drivers/counter/counter_handlers.c
index 3ba09ca..b3215fc 100644
--- a/drivers/counter/counter_handlers.c
+++ b/drivers/counter/counter_handlers.c
@@ -11,9 +11,9 @@
* instance and return an integral value
*/
#define COUNTER_HANDLER(name) \
- _SYSCALL_HANDLER(counter_ ## name, dev) \
+ Z_SYSCALL_HANDLER(counter_ ## name, dev) \
{ \
- _SYSCALL_DRIVER_COUNTER(dev, name); \
+ Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, name)); \
return _impl_counter_ ## name((struct device *)dev); \
}
diff --git a/drivers/dma/dma_handlers.c b/drivers/dma/dma_handlers.c
index 6454aa6..a85dab5 100644
--- a/drivers/dma/dma_handlers.c
+++ b/drivers/dma/dma_handlers.c
@@ -11,15 +11,15 @@
* the validity of the channel ID and returning -errno if it's bogus
*/
-_SYSCALL_HANDLER(dma_start, dev, channel)
+Z_SYSCALL_HANDLER(dma_start, dev, channel)
{
- _SYSCALL_DRIVER_DMA(dev, start);
+ Z_OOPS(Z_SYSCALL_DRIVER_DMA(dev, start));
return _impl_dma_start((struct device *)dev, channel);
}
-_SYSCALL_HANDLER(dma_stop, dev, channel)
+Z_SYSCALL_HANDLER(dma_stop, dev, channel)
{
- _SYSCALL_DRIVER_DMA(dev, stop);
+ Z_OOPS(Z_SYSCALL_DRIVER_DMA(dev, stop));
return _impl_dma_stop((struct device *)dev, channel);
}
diff --git a/drivers/entropy/entropy_handlers.c b/drivers/entropy/entropy_handlers.c
index c1a5492..b22cecc 100644
--- a/drivers/entropy/entropy_handlers.c
+++ b/drivers/entropy/entropy_handlers.c
@@ -7,10 +7,10 @@
#include <entropy.h>
#include <syscall_handler.h>
-_SYSCALL_HANDLER(entropy_get_entropy, dev, buffer, len)
+Z_SYSCALL_HANDLER(entropy_get_entropy, dev, buffer, len)
{
- _SYSCALL_DRIVER_ENTROPY(dev, get_entropy);
- _SYSCALL_MEMORY_WRITE(buffer, len);
+ Z_OOPS(Z_SYSCALL_DRIVER_ENTROPY(dev, get_entropy));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(buffer, len));
return _impl_entropy_get_entropy((struct device *)dev, (u8_t *)buffer,
len);
}
diff --git a/drivers/flash/flash_handlers.c b/drivers/flash/flash_handlers.c
index d7c2129..b0c7ec7 100644
--- a/drivers/flash/flash_handlers.c
+++ b/drivers/flash/flash_handlers.c
@@ -7,51 +7,51 @@
#include <syscall_handler.h>
#include <flash.h>
-_SYSCALL_HANDLER(flash_read, dev, offset, data, len)
+Z_SYSCALL_HANDLER(flash_read, dev, offset, data, len)
{
- _SYSCALL_DRIVER_FLASH(dev, read);
- _SYSCALL_MEMORY_WRITE(data, len);
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, read));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, len));
return _impl_flash_read((struct device *)dev, offset, (void *)data,
len);
}
-_SYSCALL_HANDLER(flash_write, dev, offset, data, len)
+Z_SYSCALL_HANDLER(flash_write, dev, offset, data, len)
{
- _SYSCALL_DRIVER_FLASH(dev, write);
- _SYSCALL_MEMORY_READ(data, len);
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, write));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(data, len));
return _impl_flash_write((struct device *)dev, offset,
(const void *)data, len);
}
-_SYSCALL_HANDLER(flash_write_protection_set, dev, enable)
+Z_SYSCALL_HANDLER(flash_write_protection_set, dev, enable)
{
- _SYSCALL_DRIVER_FLASH(dev, write_protection);
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, write_protection));
return _impl_flash_write_protection_set((struct device *)dev, enable);
}
-_SYSCALL_HANDLER1_SIMPLE(flash_get_write_block_size, K_OBJ_DRIVER_FLASH,
- struct device *);
+Z_SYSCALL_HANDLER1_SIMPLE(flash_get_write_block_size, K_OBJ_DRIVER_FLASH,
+ struct device *);
#ifdef CONFIG_FLASH_PAGE_LAYOUT
-_SYSCALL_HANDLER(flash_get_page_info_by_offs, dev, offs, info)
+Z_SYSCALL_HANDLER(flash_get_page_info_by_offs, dev, offs, info)
{
- _SYSCALL_DRIVER_FLASH(dev, page_layout);
- _SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info));
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info)));
return _impl_flash_get_page_info_by_offs((struct device *)dev, offs,
(struct flash_pages_info *)info);
}
-_SYSCALL_HANDLER(flash_get_page_info_by_idx, dev, idx, info)
+Z_SYSCALL_HANDLER(flash_get_page_info_by_idx, dev, idx, info)
{
- _SYSCALL_DRIVER_FLASH(dev, page_layout);
- _SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info));
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info)));
return _impl_flash_get_page_info_by_idx((struct device *)dev, idx,
(struct flash_pages_info *)info);
}
-_SYSCALL_HANDLER(flash_get_page_count, dev)
+Z_SYSCALL_HANDLER(flash_get_page_count, dev)
{
- _SYSCALL_DRIVER_FLASH(dev, page_layout);
+ Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout));
return _impl_flash_get_page_count((struct device *)dev);
}
#endif
diff --git a/drivers/gpio/gpio_handlers.c b/drivers/gpio/gpio_handlers.c
index e48a9c4..625c188 100644
--- a/drivers/gpio/gpio_handlers.c
+++ b/drivers/gpio/gpio_handlers.c
@@ -7,42 +7,42 @@
#include <gpio.h>
#include <syscall_handler.h>
-_SYSCALL_HANDLER(gpio_config, port, access_op, pin, flags)
+Z_SYSCALL_HANDLER(gpio_config, port, access_op, pin, flags)
{
- _SYSCALL_DRIVER_GPIO(port, config);
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, config));
return _impl_gpio_config((struct device *)port, access_op, pin, flags);
}
-_SYSCALL_HANDLER(gpio_write, port, access_op, pin, value)
+Z_SYSCALL_HANDLER(gpio_write, port, access_op, pin, value)
{
- _SYSCALL_DRIVER_GPIO(port, write);
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, write));
return _impl_gpio_write((struct device *)port, access_op, pin, value);
}
-_SYSCALL_HANDLER(gpio_read, port, access_op, pin, value)
+Z_SYSCALL_HANDLER(gpio_read, port, access_op, pin, value)
{
- _SYSCALL_DRIVER_GPIO(port, read);
- _SYSCALL_MEMORY_WRITE(value, sizeof(u32_t));
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, read));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(value, sizeof(u32_t)));
return _impl_gpio_read((struct device *)port, access_op, pin,
(u32_t *)value);
}
-_SYSCALL_HANDLER(gpio_enable_callback, port, access_op, pin)
+Z_SYSCALL_HANDLER(gpio_enable_callback, port, access_op, pin)
{
- _SYSCALL_DRIVER_GPIO(port, enable_callback);
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, enable_callback));
return _impl_gpio_enable_callback((struct device *)port, access_op,
pin);
}
-_SYSCALL_HANDLER(gpio_disable_callback, port, access_op, pin)
+Z_SYSCALL_HANDLER(gpio_disable_callback, port, access_op, pin)
{
- _SYSCALL_DRIVER_GPIO(port, disable_callback);
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, disable_callback));
return _impl_gpio_disable_callback((struct device *)port, access_op,
pin);
}
-_SYSCALL_HANDLER(gpio_get_pending_int, port)
+Z_SYSCALL_HANDLER(gpio_get_pending_int, port)
{
- _SYSCALL_DRIVER_GPIO(port, get_pending_int);
+ Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, get_pending_int));
return _impl_gpio_get_pending_int((struct device *)port);
}
diff --git a/drivers/i2c/i2c_handlers.c b/drivers/i2c/i2c_handlers.c
index de7068f..9671922 100644
--- a/drivers/i2c/i2c_handlers.c
+++ b/drivers/i2c/i2c_handlers.c
@@ -8,9 +8,9 @@
#include <string.h>
#include <syscall_handler.h>
-_SYSCALL_HANDLER(i2c_configure, dev, dev_config)
+Z_SYSCALL_HANDLER(i2c_configure, dev, dev_config)
{
- _SYSCALL_DRIVER_I2C(dev, configure);
+ Z_OOPS(Z_SYSCALL_DRIVER_I2C(dev, configure));
return _impl_i2c_configure((struct device *)dev, dev_config);
}
@@ -30,26 +30,27 @@
* that the target buffer be writable
*/
for (i = 0; i < num_msgs; i++) {
- _SYSCALL_MEMORY(copy[i].buf, copy[i].len,
- copy[i].flags & I2C_MSG_READ);
+ Z_OOPS(Z_SYSCALL_MEMORY(copy[i].buf, copy[i].len,
+ copy[i].flags & I2C_MSG_READ));
}
return _impl_i2c_transfer(dev, copy, num_msgs, addr);
}
-_SYSCALL_HANDLER(i2c_transfer, dev, msgs, num_msgs, addr)
+Z_SYSCALL_HANDLER(i2c_transfer, dev, msgs, num_msgs, addr)
{
- _SYSCALL_OBJ(dev, K_OBJ_DRIVER_I2C);
+ Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_I2C));
/* copy_msgs_and_transfer() will allocate a copy on the stack using
* VLA, so ensure this won't blow the stack. Most functions defined
* in i2c.h use only a handful of messages, so up to 32 messages
* should be more than sufficient.
*/
- _SYSCALL_VERIFY(num_msgs >= 1 && num_msgs < 32);
+ Z_OOPS(Z_SYSCALL_VERIFY(num_msgs >= 1 && num_msgs < 32));
/* We need to be able to read the overall array of messages */
- _SYSCALL_MEMORY_ARRAY_READ(msgs, num_msgs, sizeof(struct i2c_msg));
+ Z_OOPS(Z_SYSCALL_MEMORY_ARRAY_READ(msgs, num_msgs,
+ sizeof(struct i2c_msg)));
return copy_msgs_and_transfer((struct device *)dev,
(struct i2c_msg *)msgs,
diff --git a/drivers/ipm/ipm_handlers.c b/drivers/ipm/ipm_handlers.c
index 75bb8f8..48e4c4c 100644
--- a/drivers/ipm/ipm_handlers.c
+++ b/drivers/ipm/ipm_handlers.c
@@ -7,28 +7,28 @@
#include <syscall_handler.h>
#include <ipm.h>
-_SYSCALL_HANDLER(ipm_send, dev, wait, id, data, size)
+Z_SYSCALL_HANDLER(ipm_send, dev, wait, id, data, size)
{
- _SYSCALL_DRIVER_IPM(dev, send);
- _SYSCALL_MEMORY_READ(data, size);
+ Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, send));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(data, size));
return _impl_ipm_send((struct device *)dev, wait, id,
(const void *)data, size);
}
-_SYSCALL_HANDLER(ipm_max_data_size_get, dev)
+Z_SYSCALL_HANDLER(ipm_max_data_size_get, dev)
{
- _SYSCALL_DRIVER_IPM(dev, max_data_size_get);
+ Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, max_data_size_get));
return _impl_max_data_size_get((struct device *)dev);
}
-_SYSCALL_HANDLER(ipm_max_id_val_get, dev)
+Z_SYSCALL_HANDLER(ipm_max_id_val_get, dev)
{
- _SYSCALL_DRIVER_IPM(dev, max_id_val_get);
+ Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, max_id_val_get));
return _impl_max_id_val_get((struct device *)dev);
}
-_SYSCALL_HANDLER(ipm_set_enabled, dev, enable)
+Z_SYSCALL_HANDLER(ipm_set_enabled, dev, enable)
{
- _SYSCALL_DRIVER_IPM(dev, set_enabled);
+ Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, set_enabled));
return _impl_ipm_set_enabled((struct device *)dev, enable);
}
diff --git a/drivers/led/led_handlers.c b/drivers/led/led_handlers.c
index d5ea70e..dbcf33b 100644
--- a/drivers/led/led_handlers.c
+++ b/drivers/led/led_handlers.c
@@ -7,27 +7,27 @@
#include <syscall_handler.h>
#include <led.h>
-_SYSCALL_HANDLER(led_blink, dev, led, delay_on, delay_off)
+Z_SYSCALL_HANDLER(led_blink, dev, led, delay_on, delay_off)
{
- _SYSCALL_DRIVER_LED(dev, blink);
+ Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, blink));
return _impl_led_blink((struct device *)dev, led, delay_on,
delay_off);
}
-_SYSCALL_HANDLER(led_set_brightness, dev, led, value)
+Z_SYSCALL_HANDLER(led_set_brightness, dev, led, value)
{
- _SYSCALL_DRIVER_LED(dev, set_brightness);
+ Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, set_brightness));
return _impl_led_set_brightness((struct device *)dev, led, value);
}
-_SYSCALL_HANDLER(led_on, dev, led)
+Z_SYSCALL_HANDLER(led_on, dev, led)
{
- _SYSCALL_DRIVER_LED(dev, on);
+ Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, on));
return _impl_led_on((struct device *)dev, led);
}
-_SYSCALL_HANDLER(led_off, dev, led)
+Z_SYSCALL_HANDLER(led_off, dev, led)
{
- _SYSCALL_DRIVER_LED(dev, off);
+ Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, off));
return _impl_led_off((struct device *)dev, led);
}
diff --git a/drivers/pwm/pwm_handlers.c b/drivers/pwm/pwm_handlers.c
index 5fe37de..df2239a 100644
--- a/drivers/pwm/pwm_handlers.c
+++ b/drivers/pwm/pwm_handlers.c
@@ -7,17 +7,17 @@
#include <syscall_handler.h>
#include <pwm.h>
-_SYSCALL_HANDLER(pwm_pin_set_cycles, dev, pwm, period, pulse)
+Z_SYSCALL_HANDLER(pwm_pin_set_cycles, dev, pwm, period, pulse)
{
- _SYSCALL_DRIVER_PWM(dev, pin_set);
+ Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, pin_set));
return _impl_pwm_pin_set_cycles((struct device *)dev, pwm, period,
pulse);
}
-_SYSCALL_HANDLER(pwm_get_cycles_per_sec, dev, pwm, cycles)
+Z_SYSCALL_HANDLER(pwm_get_cycles_per_sec, dev, pwm, cycles)
{
- _SYSCALL_DRIVER_PWM(dev, get_cycles_per_sec);
- _SYSCALL_MEMORY_WRITE(cycles, sizeof(u64_t));
+ Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, get_cycles_per_sec));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(cycles, sizeof(u64_t)));
return _impl_pwm_get_cycles_per_sec((struct device *)dev,
pwm, (u64_t *)cycles);
}
diff --git a/drivers/rtc/rtc_handlers.c b/drivers/rtc/rtc_handlers.c
index b5034d5..fea2f53 100644
--- a/drivers/rtc/rtc_handlers.c
+++ b/drivers/rtc/rtc_handlers.c
@@ -7,32 +7,32 @@
#include <syscall_handler.h>
#include <rtc.h>
-_SYSCALL_HANDLER(rtc_read, dev)
+Z_SYSCALL_HANDLER(rtc_read, dev)
{
- _SYSCALL_DRIVER_RTC(dev, read);
+ Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, read));
return _impl_rtc_read((struct device *)dev);
}
-_SYSCALL_HANDLER(rtc_enable, dev)
+Z_SYSCALL_HANDLER(rtc_enable, dev)
{
- _SYSCALL_DRIVER_RTC(dev, enable);
+ Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, enable));
return _impl_rtc_enable((struct device *)dev);
}
-_SYSCALL_HANDLER(rtc_disable, dev)
+Z_SYSCALL_HANDLER(rtc_disable, dev)
{
- _SYSCALL_DRIVER_RTC(dev, disable);
+ Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, disable));
return _impl_rtc_disable((struct device *)dev);
}
-_SYSCALL_HANDLER(rtc_set_alarm, dev, alarm_val)
+Z_SYSCALL_HANDLER(rtc_set_alarm, dev, alarm_val)
{
- _SYSCALL_DRIVER_RTC(dev, set_alarm);
+ Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, set_alarm));
return _impl_rtc_set_alarm((struct device *)dev, alarm_val);
}
-_SYSCALL_HANDLER(rtc_get_pending_int, dev)
+Z_SYSCALL_HANDLER(rtc_get_pending_int, dev)
{
- _SYSCALL_DRIVER_RTC(dev, get_pending_int);
+ Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, get_pending_int));
return _impl_rtc_get_pending_int((struct device *)dev);
}
diff --git a/drivers/sensor/sensor_handlers.c b/drivers/sensor/sensor_handlers.c
index 02676b3..94a1e4a 100644
--- a/drivers/sensor/sensor_handlers.c
+++ b/drivers/sensor/sensor_handlers.c
@@ -7,30 +7,30 @@
#include <sensor.h>
#include <syscall_handler.h>
-_SYSCALL_HANDLER(sensor_attr_set, dev, chan, attr, val)
+Z_SYSCALL_HANDLER(sensor_attr_set, dev, chan, attr, val)
{
- _SYSCALL_DRIVER_SENSOR(dev, attr_set);
- _SYSCALL_MEMORY_READ(val, sizeof(struct sensor_value));
+ Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, attr_set));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(val, sizeof(struct sensor_value)));
return _impl_sensor_attr_set((struct device *)dev, chan, attr,
(const struct sensor_value *)val);
}
-_SYSCALL_HANDLER(sensor_sample_sample_fetch, dev)
+Z_SYSCALL_HANDLER(sensor_sample_sample_fetch, dev)
{
- _SYSCALL_DRIVER_SENSOR(dev, sample_fetch);
+ Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return _impl_sensor_sample_fetch((struct device *)dev);
}
-_SYSCALL_HANDLER(sensor_sample_fetch_chan, dev, type)
+Z_SYSCALL_HANDLER(sensor_sample_fetch_chan, dev, type)
{
- _SYSCALL_DRIVER_SENSOR(dev, sample_fetch);
+ Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return _impl_sensor_sample_fetch_chan((struct device *)dev, type);
}
-_SYSCALL_HANDLER(sensor_channel_get, dev, chan, val)
+Z_SYSCALL_HANDLER(sensor_channel_get, dev, chan, val)
{
- _SYSCALL_DRIVER_SENSOR(dev, channel_get);
- _SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value));
+ Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, channel_get));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value)));
return _impl_sensor_channel_get((struct device *)dev, chan,
(struct sensor_value *)val);
}
diff --git a/drivers/serial/uart_handlers.c b/drivers/serial/uart_handlers.c
index eb9d5c8..ac6e2de 100644
--- a/drivers/serial/uart_handlers.c
+++ b/drivers/serial/uart_handlers.c
@@ -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 @@
#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 */
diff --git a/drivers/spi/spi_handlers.c b/drivers/spi/spi_handlers.c
index 8f1b5fe..30a4db8 100644
--- a/drivers/spi/spi_handlers.c
+++ b/drivers/spi/spi_handlers.c
@@ -22,9 +22,9 @@
}
/* Validate the array of struct spi_buf instances */
- _SYSCALL_MEMORY_ARRAY_READ(bufs->buffers,
- bufs->count,
- sizeof(struct spi_buf));
+ Z_OOPS(Z_SYSCALL_MEMORY_ARRAY_READ(bufs->buffers,
+ bufs->count,
+ sizeof(struct spi_buf)));;
/* Not worried abuot overflow here: _SYSCALL_MEMORY_ARRAY_READ()
* takes care of it.
@@ -39,7 +39,7 @@
*/
struct spi_buf *buf = &bufs->buffers[i];
- _SYSCALL_MEMORY(buf->buf, buf->len, writable);
+ Z_OOPS(Z_SYSCALL_MEMORY(buf->buf, buf->len, writable));
}
}
@@ -65,23 +65,24 @@
tx_bufs, rx_bufs);
}
-_SYSCALL_HANDLER(spi_transceive, dev, config_p, tx_bufs, rx_bufs)
+Z_SYSCALL_HANDLER(spi_transceive, dev, config_p, tx_bufs, rx_bufs)
{
const struct spi_config *config = (const struct spi_config *)config_p;
struct spi_buf_set tx_bufs_copy;
struct spi_buf_set rx_bufs_copy;
struct spi_config config_copy;
- _SYSCALL_MEMORY_READ(config, sizeof(*config));
- _SYSCALL_DRIVER_SPI(dev, transceive);
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(config, sizeof(*config)));
+ Z_OOPS(Z_SYSCALL_DRIVER_SPI(dev, transceive));
if (tx_bufs) {
const struct spi_buf_set *tx =
(const struct spi_buf_set *)tx_bufs;
- _SYSCALL_MEMORY_READ(tx_bufs, sizeof(struct spi_buf_set));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(tx_bufs,
+ sizeof(struct spi_buf_set)));
memcpy(&tx_bufs_copy, tx, sizeof(tx_bufs_copy));
- _SYSCALL_VERIFY(tx_bufs_copy.count < 32);
+ Z_OOPS(Z_SYSCALL_VERIFY(tx_bufs_copy.count < 32));
} else {
memset(&tx_bufs_copy, 0, sizeof(tx_bufs_copy));
}
@@ -90,9 +91,10 @@
const struct spi_buf_set *rx =
(const struct spi_buf_set *)rx_bufs;
- _SYSCALL_MEMORY_READ(rx_bufs, sizeof(struct spi_buf_set));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(rx_bufs,
+ sizeof(struct spi_buf_set)));
memcpy(&rx_bufs_copy, rx, sizeof(rx_bufs_copy));
- _SYSCALL_VERIFY(rx_bufs_copy.count < 32);
+ Z_OOPS(Z_SYSCALL_VERIFY(rx_bufs_copy.count < 32));
} else {
memset(&rx_bufs_copy, 0, sizeof(rx_bufs_copy));
}
@@ -101,9 +103,9 @@
if (config_copy.cs) {
const struct spi_cs_control *cs = config_copy.cs;
- _SYSCALL_MEMORY_READ(cs, sizeof(*cs));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(cs, sizeof(*cs)));
if (cs->gpio_dev) {
- _SYSCALL_OBJ(cs->gpio_dev, K_OBJ_DRIVER_GPIO);
+ Z_OOPS(Z_SYSCALL_OBJ(cs->gpio_dev, K_OBJ_DRIVER_GPIO));
}
}
@@ -117,11 +119,11 @@
ssf);
}
-_SYSCALL_HANDLER(spi_release, dev, config_p)
+Z_SYSCALL_HANDLER(spi_release, dev, config_p)
{
const struct spi_config *config = (const struct spi_config *)config_p;
- _SYSCALL_MEMORY_READ(config, sizeof(*config));
- _SYSCALL_DRIVER_SPI(dev, release);
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(config, sizeof(*config)));
+ Z_OOPS(Z_SYSCALL_DRIVER_SPI(dev, release));
return _impl_spi_release((struct device *)dev, config);
}
diff --git a/kernel/alert.c b/kernel/alert.c
index c97028c..6d7a3d0 100644
--- a/kernel/alert.c
+++ b/kernel/alert.c
@@ -92,7 +92,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_alert_send, K_OBJ_ALERT, struct k_alert *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_alert_send, K_OBJ_ALERT, struct k_alert *);
#endif
int _impl_k_alert_recv(struct k_alert *alert, s32_t timeout)
@@ -101,9 +101,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_alert_recv, alert, timeout)
+Z_SYSCALL_HANDLER(k_alert_recv, alert, timeout)
{
- _SYSCALL_OBJ(alert, K_OBJ_ALERT);
+ Z_OOPS(Z_SYSCALL_OBJ(alert, K_OBJ_ALERT));
return _impl_k_alert_recv((struct k_alert *)alert, timeout);
}
#endif
diff --git a/kernel/include/syscall_handler.h b/kernel/include/syscall_handler.h
index 33ae31e..6a25f68 100644
--- a/kernel/include/syscall_handler.h
+++ b/kernel/include/syscall_handler.h
@@ -125,6 +125,27 @@
*/
void _k_object_uninit(void *obj);
+#define Z_OOPS(expr) \
+ do { \
+ if (expr) { \
+ _arch_syscall_oops(ssf); \
+ } \
+ } while (0)
+
+static inline __attribute__((warn_unused_result)) __printf_like(2, 3)
+bool z_syscall_verify_msg(bool expr, const char *fmt, ...)
+{
+ va_list ap;
+
+ if (expr) {
+ va_start(ap, fmt);
+ vprintk(fmt, ap);
+ va_end(ap);
+ }
+
+ return expr;
+}
+
/**
* @brief Runtime expression check for system call arguments
*
@@ -136,15 +157,11 @@
* oops
* @param fmt Printf-style format string (followed by appropriate variadic
* arguments) to print on verification failure
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_VERIFY_MSG(expr, fmt, ...) \
- do { \
- if (!(expr)) { \
- printk("FATAL: syscall %s failed check: " fmt "\n", \
- __func__, ##__VA_ARGS__); \
- _arch_syscall_oops(ssf); \
- } \
- } while (0)
+#define Z_SYSCALL_VERIFY_MSG(expr, fmt, ...) \
+ z_syscall_verify_msg(!(expr), "syscall %s failed check: " fmt "\n", \
+ __func__, ##__VA_ARGS__)
/**
* @brief Runtime expression check for system call arguments
@@ -154,14 +171,15 @@
*
* @param expr Boolean expression to verify, a false result will trigger an
* oops. A stringified version of this expression will be printed.
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_VERIFY(expr) _SYSCALL_VERIFY_MSG(expr, #expr)
+#define Z_SYSCALL_VERIFY(expr) Z_SYSCALL_VERIFY_MSG(expr, #expr)
-#define _SYSCALL_MEMORY(ptr, size, write) \
- _SYSCALL_VERIFY_MSG(!_arch_buffer_validate((void *)ptr, size, write), \
- "Memory region %p (size %u) %s access denied", \
- (void *)(ptr), (u32_t)(size), \
- write ? "write" : "read")
+#define Z_SYSCALL_MEMORY(ptr, size, write) \
+ Z_SYSCALL_VERIFY_MSG(!_arch_buffer_validate((void *)ptr, size, write), \
+ "Memory region %p (size %u) %s access denied", \
+ (void *)(ptr), (u32_t)(size), \
+ write ? "write" : "read")
/**
* @brief Runtime check that a user thread has read permission to a memory area
@@ -176,9 +194,10 @@
* @param size Size of the memory area
* @param write If the thread should be able to write to this memory, not just
* read it
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_MEMORY_READ(ptr, size) \
- _SYSCALL_MEMORY(ptr, size, 0)
+#define Z_SYSCALL_MEMORY_READ(ptr, size) \
+ Z_SYSCALL_MEMORY(ptr, size, 0)
/**
* @brief Runtime check that a user thread has write permission to a memory area
@@ -193,20 +212,21 @@
* @param size Size of the memory area
* @param write If the thread should be able to write to this memory, not just
* read it
+ * @param 0 on success, nonzero on failure
*/
-#define _SYSCALL_MEMORY_WRITE(ptr, size) \
- _SYSCALL_MEMORY(ptr, size, 1)
+#define Z_SYSCALL_MEMORY_WRITE(ptr, size) \
+ Z_SYSCALL_MEMORY(ptr, size, 1)
-#define _SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, write) \
- do { \
+#define Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, write) \
+ ({ \
u32_t product; \
- _SYSCALL_VERIFY_MSG(!__builtin_umul_overflow((u32_t)(nmemb), \
- (u32_t)(size), \
- &product), \
- "%ux%u array is too large", \
- (u32_t)(nmemb), (u32_t)(size)); \
- _SYSCALL_MEMORY(ptr, product, write); \
- } while (0)
+ Z_SYSCALL_VERIFY_MSG(!__builtin_umul_overflow((u32_t)(nmemb), \
+ (u32_t)(size), \
+ &product), \
+ "%ux%u array is too large", \
+ (u32_t)(nmemb), (u32_t)(size)) || \
+ Z_SYSCALL_MEMORY(ptr, product, write); \
+ })
/**
* @brief Validate user thread has read permission for sized array
@@ -218,9 +238,10 @@
* @param ptr Memory area to examine
* @param nmemb Number of elements in the array
* @param size Size of each array element
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_MEMORY_ARRAY_READ(ptr, nmemb, size) \
- _SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 0)
+#define Z_SYSCALL_MEMORY_ARRAY_READ(ptr, nmemb, size) \
+ Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 0)
/**
* @brief Validate user thread has read/write permission for sized array
@@ -232,9 +253,10 @@
* @param ptr Memory area to examine
* @param nmemb Number of elements in the array
* @param size Size of each array element
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_MEMORY_ARRAY_WRITE(ptr, nmemb, size) \
- _SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 1)
+#define Z_SYSCALL_MEMORY_ARRAY_WRITE(ptr, nmemb, size) \
+ Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 1)
static inline int _obj_validation_check(struct _k_object *ko,
void *obj,
@@ -256,8 +278,8 @@
return ret;
}
-#define _SYSCALL_IS_OBJ(ptr, type, init) \
- _SYSCALL_VERIFY_MSG( \
+#define Z_SYSCALL_IS_OBJ(ptr, type, init) \
+ Z_SYSCALL_VERIFY_MSG( \
!_obj_validation_check(_k_object_find((void *)ptr), (void *)ptr, \
type, init), "access denied")
@@ -269,16 +291,17 @@
* @param ptr Untrusted device instance object pointer
* @param api_struct Name of the driver API struct (e.g. gpio_driver_api)
* @param op Driver operation (e.g. manage_callback)
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_DRIVER_OP(ptr, api_name, op) \
- do { \
+#define Z_SYSCALL_DRIVER_OP(ptr, api_name, op) \
+ ({ \
struct api_name *__device__ = (struct api_name *) \
((struct device *)ptr)->driver_api; \
- _SYSCALL_VERIFY_MSG(__device__->op != NULL, \
+ Z_SYSCALL_VERIFY_MSG(__device__->op != NULL, \
"Operation %s not defined for driver " \
"instance %p", \
# op, __device__); \
- } while (0)
+ })
/**
* @brief Runtime check kernel object pointer for non-init functions
@@ -289,9 +312,10 @@
*
* @param ptr Untrusted kernel object pointer
* @param type Expected kernel object type
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_OBJ(ptr, type) \
- _SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_TRUE)
+#define Z_SYSCALL_OBJ(ptr, type) \
+ Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_TRUE)
/**
* @brief Runtime check kernel object pointer for non-init functions
@@ -301,10 +325,11 @@
*
* @param ptr Untrusted kernel object pointer
* @param type Expected kernel object type
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_OBJ_INIT(ptr, type) \
- _SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_ANY)
+#define Z_SYSCALL_OBJ_INIT(ptr, type) \
+ Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_ANY)
/**
* @brief Runtime check kernel object pointer for non-init functions
@@ -316,10 +341,11 @@
*
* @param ptr Untrusted kernel object pointer
* @param type Expected kernel object type
+ * @return 0 on success, nonzero on failure
*/
-#define _SYSCALL_OBJ_NEVER_INIT(ptr, type) \
- _SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_FALSE)
+#define Z_SYSCALL_OBJ_NEVER_INIT(ptr, type) \
+ Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_FALSE)
/*
* Handler definition macros
@@ -410,7 +436,7 @@
#define __SYSCALL_ARG_N(_1, _2, _3, _4, _5, _6, _7, N, ...) N
#define __SYSCALL_RSEQ_N() 6, 5, 4, 3, 2, 1, 0
-#define _SYSCALL_HANDLER(...) \
+#define Z_SYSCALL_HANDLER(...) \
_SYSCALL_CONCAT(__SYSCALL_HANDLER, \
_SYSCALL_NARG(__VA_ARGS__))(__VA_ARGS__)
@@ -420,25 +446,25 @@
* and call the implementation.
*/
-#define _SYSCALL_HANDLER1_SIMPLE(name_, obj_enum_, obj_type_) \
+#define Z_SYSCALL_HANDLER1_SIMPLE(name_, obj_enum_, obj_type_) \
__SYSCALL_HANDLER1(name_, arg1) { \
- _SYSCALL_OBJ(arg1, obj_enum_); \
+ Z_OOPS(Z_SYSCALL_OBJ(arg1, obj_enum_)); \
return (u32_t)_impl_ ## name_((obj_type_)arg1); \
}
-#define _SYSCALL_HANDLER1_SIMPLE_VOID(name_, obj_enum_, obj_type_) \
+#define Z_SYSCALL_HANDLER1_SIMPLE_VOID(name_, obj_enum_, obj_type_) \
__SYSCALL_HANDLER1(name_, arg1) { \
- _SYSCALL_OBJ(arg1, obj_enum_); \
+ Z_OOPS(Z_SYSCALL_OBJ(arg1, obj_enum_)); \
_impl_ ## name_((obj_type_)arg1); \
return 0; \
}
-#define _SYSCALL_HANDLER0_SIMPLE(name_) \
+#define Z_SYSCALL_HANDLER0_SIMPLE(name_) \
__SYSCALL_HANDLER0(name_) { \
return (u32_t)_impl_ ## name_(); \
}
-#define _SYSCALL_HANDLER0_SIMPLE_VOID(name_) \
+#define Z_SYSCALL_HANDLER0_SIMPLE_VOID(name_) \
__SYSCALL_HANDLER0(name_) { \
_impl_ ## name_(); \
return 0; \
diff --git a/kernel/msg_q.c b/kernel/msg_q.c
index 8c388a2..a14907c 100644
--- a/kernel/msg_q.c
+++ b/kernel/msg_q.c
@@ -89,9 +89,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_msgq_alloc_init, q, msg_size, max_msgs)
+Z_SYSCALL_HANDLER(k_msgq_alloc_init, q, msg_size, max_msgs)
{
- _SYSCALL_OBJ_NEVER_INIT(q, K_OBJ_MSGQ);
+ Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(q, K_OBJ_MSGQ));
return _impl_k_msgq_alloc_init((struct k_msgq *)q, msg_size, max_msgs);
}
@@ -153,12 +153,12 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_msgq_put, msgq_p, data, timeout)
+Z_SYSCALL_HANDLER(k_msgq_put, msgq_p, data, timeout)
{
struct k_msgq *q = (struct k_msgq *)msgq_p;
- _SYSCALL_OBJ(q, K_OBJ_MSGQ);
- _SYSCALL_MEMORY_READ(data, q->msg_size);
+ Z_OOPS(Z_SYSCALL_OBJ(q, K_OBJ_MSGQ));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(data, q->msg_size));
return _impl_k_msgq_put(q, (void *)data, timeout);
}
@@ -172,12 +172,12 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_msgq_get_attrs, msgq_p, attrs)
+Z_SYSCALL_HANDLER(k_msgq_get_attrs, msgq_p, attrs)
{
struct k_msgq *q = (struct k_msgq *)msgq_p;
- _SYSCALL_OBJ(q, K_OBJ_MSGQ);
- _SYSCALL_MEMORY_WRITE(attrs, sizeof(struct k_msgq_attrs));
+ Z_OOPS(Z_SYSCALL_OBJ(q, K_OBJ_MSGQ));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(attrs, sizeof(struct k_msgq_attrs)));
_impl_k_msgq_get_attrs(q, (struct k_msgq_attrs *) attrs);
return 0;
}
@@ -234,12 +234,12 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_msgq_get, msgq_p, data, timeout)
+Z_SYSCALL_HANDLER(k_msgq_get, msgq_p, data, timeout)
{
struct k_msgq *q = (struct k_msgq *)msgq_p;
- _SYSCALL_OBJ(q, K_OBJ_MSGQ);
- _SYSCALL_MEMORY_WRITE(data, q->msg_size);
+ Z_OOPS(Z_SYSCALL_OBJ(q, K_OBJ_MSGQ));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, q->msg_size));
return _impl_k_msgq_get(q, (void *)data, timeout);
}
@@ -263,7 +263,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_msgq_purge, K_OBJ_MSGQ, struct k_msgq *);
-_SYSCALL_HANDLER1_SIMPLE(k_msgq_num_free_get, K_OBJ_MSGQ, struct k_msgq *);
-_SYSCALL_HANDLER1_SIMPLE(k_msgq_num_used_get, K_OBJ_MSGQ, struct k_msgq *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_msgq_purge, K_OBJ_MSGQ, struct k_msgq *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_msgq_num_free_get, K_OBJ_MSGQ, struct k_msgq *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_msgq_num_used_get, K_OBJ_MSGQ, struct k_msgq *);
#endif
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 5bdf5b9..a110201 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -82,9 +82,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_mutex_init, mutex)
+Z_SYSCALL_HANDLER(k_mutex_init, mutex)
{
- _SYSCALL_OBJ_INIT(mutex, K_OBJ_MUTEX);
+ Z_OOPS(Z_SYSCALL_OBJ_INIT(mutex, K_OBJ_MUTEX));
_impl_k_mutex_init((struct k_mutex *)mutex);
return 0;
@@ -192,9 +192,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_mutex_lock, mutex, timeout)
+Z_SYSCALL_HANDLER(k_mutex_lock, mutex, timeout)
{
- _SYSCALL_OBJ(mutex, K_OBJ_MUTEX);
+ Z_OOPS(Z_SYSCALL_OBJ(mutex, K_OBJ_MUTEX));
return _impl_k_mutex_lock((struct k_mutex *)mutex, (s32_t)timeout);
}
#endif
@@ -252,11 +252,11 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_mutex_unlock, mutex)
+Z_SYSCALL_HANDLER(k_mutex_unlock, mutex)
{
- _SYSCALL_OBJ(mutex, K_OBJ_MUTEX);
- _SYSCALL_VERIFY(((struct k_mutex *)mutex)->lock_count > 0);
- _SYSCALL_VERIFY(((struct k_mutex *)mutex)->owner == _current);
+ Z_OOPS(Z_SYSCALL_OBJ(mutex, K_OBJ_MUTEX));
+ Z_OOPS(Z_SYSCALL_VERIFY(((struct k_mutex *)mutex)->lock_count > 0));
+ Z_OOPS(Z_SYSCALL_VERIFY(((struct k_mutex *)mutex)->owner == _current));
_impl_k_mutex_unlock((struct k_mutex *)mutex);
return 0;
}
diff --git a/kernel/pipes.c b/kernel/pipes.c
index 66282bf..d77a527 100644
--- a/kernel/pipes.c
+++ b/kernel/pipes.c
@@ -165,9 +165,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_pipe_alloc_init, pipe, size)
+Z_SYSCALL_HANDLER(k_pipe_alloc_init, pipe, size)
{
- _SYSCALL_OBJ_NEVER_INIT(pipe, K_OBJ_PIPE);
+ Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(pipe, K_OBJ_PIPE));
return _impl_k_pipe_alloc_init((struct k_pipe *)pipe, size);
}
@@ -714,16 +714,16 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_pipe_get,
+Z_SYSCALL_HANDLER(k_pipe_get,
pipe, data, bytes_to_read, bytes_read_p, min_xfer_p, timeout)
{
size_t *bytes_read = (size_t *)bytes_read_p;
size_t min_xfer = (size_t)min_xfer_p;
- _SYSCALL_OBJ(pipe, K_OBJ_PIPE);
- _SYSCALL_MEMORY_WRITE(bytes_read, sizeof(*bytes_read));
- _SYSCALL_MEMORY_WRITE((void *)data, bytes_to_read);
- _SYSCALL_VERIFY(min_xfer <= bytes_to_read);
+ Z_OOPS(Z_SYSCALL_OBJ(pipe, K_OBJ_PIPE));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(bytes_read, sizeof(*bytes_read)));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE((void *)data, bytes_to_read));
+ Z_OOPS(Z_SYSCALL_VERIFY(min_xfer <= bytes_to_read));
return _impl_k_pipe_get((struct k_pipe *)pipe, (void *)data,
bytes_to_read, bytes_read, min_xfer,
@@ -743,16 +743,16 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_pipe_put, pipe, data, bytes_to_write, bytes_written_p,
+Z_SYSCALL_HANDLER(k_pipe_put, pipe, data, bytes_to_write, bytes_written_p,
min_xfer_p, timeout)
{
size_t *bytes_written = (size_t *)bytes_written_p;
size_t min_xfer = (size_t)min_xfer_p;
- _SYSCALL_OBJ(pipe, K_OBJ_PIPE);
- _SYSCALL_MEMORY_WRITE(bytes_written, sizeof(*bytes_written));
- _SYSCALL_MEMORY_READ((void *)data, bytes_to_write);
- _SYSCALL_VERIFY(min_xfer <= bytes_to_write);
+ Z_OOPS(Z_SYSCALL_OBJ(pipe, K_OBJ_PIPE));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(bytes_written, sizeof(*bytes_written)));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ((void *)data, bytes_to_write));
+ Z_OOPS(Z_SYSCALL_VERIFY(min_xfer <= bytes_to_write));
return _impl_k_pipe_put((struct k_pipe *)pipe, (void *)data,
bytes_to_write, bytes_written, min_xfer,
diff --git a/kernel/queue.c b/kernel/queue.c
index 426588f..3426277 100644
--- a/kernel/queue.c
+++ b/kernel/queue.c
@@ -94,11 +94,11 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_queue_init, queue_ptr)
+Z_SYSCALL_HANDLER(k_queue_init, queue_ptr)
{
struct k_queue *queue = (struct k_queue *)queue_ptr;
- _SYSCALL_OBJ_NEVER_INIT(queue, K_OBJ_QUEUE);
+ Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(queue, K_OBJ_QUEUE));
_impl_k_queue_init(queue);
return 0;
}
@@ -138,8 +138,8 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_queue_cancel_wait, K_OBJ_QUEUE,
- struct k_queue *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_queue_cancel_wait, K_OBJ_QUEUE,
+ struct k_queue *);
#endif
static int queue_insert(struct k_queue *queue, void *prev, void *data,
@@ -204,9 +204,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_queue_alloc_append, queue, data)
+Z_SYSCALL_HANDLER(k_queue_alloc_append, queue, data)
{
- _SYSCALL_OBJ(queue, K_OBJ_QUEUE);
+ Z_OOPS(Z_SYSCALL_OBJ(queue, K_OBJ_QUEUE));
return _impl_k_queue_alloc_append((struct k_queue *)queue,
(void *)data);
@@ -219,9 +219,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_queue_alloc_prepend, queue, data)
+Z_SYSCALL_HANDLER(k_queue_alloc_prepend, queue, data)
{
- _SYSCALL_OBJ(queue, K_OBJ_QUEUE);
+ Z_OOPS(Z_SYSCALL_OBJ(queue, K_OBJ_QUEUE));
return _impl_k_queue_alloc_prepend((struct k_queue *)queue,
(void *)data);
@@ -338,16 +338,16 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_queue_get, queue, timeout_p)
+Z_SYSCALL_HANDLER(k_queue_get, queue, timeout_p)
{
s32_t timeout = timeout_p;
- _SYSCALL_OBJ(queue, K_OBJ_QUEUE);
+ Z_OOPS(Z_SYSCALL_OBJ(queue, K_OBJ_QUEUE));
return (u32_t)_impl_k_queue_get((struct k_queue *)queue, timeout);
}
-_SYSCALL_HANDLER1_SIMPLE(k_queue_is_empty, K_OBJ_QUEUE, struct k_queue *);
-_SYSCALL_HANDLER1_SIMPLE(k_queue_peek_head, K_OBJ_QUEUE, struct k_queue *);
-_SYSCALL_HANDLER1_SIMPLE(k_queue_peek_tail, K_OBJ_QUEUE, struct k_queue *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_queue_is_empty, K_OBJ_QUEUE, struct k_queue *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_queue_peek_head, K_OBJ_QUEUE, struct k_queue *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_queue_peek_tail, K_OBJ_QUEUE, struct k_queue *);
#endif /* CONFIG_USERSPACE */
diff --git a/kernel/sched.c b/kernel/sched.c
index 3bd82c4..ef7a685 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -354,8 +354,8 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE(k_thread_priority_get, K_OBJ_THREAD,
- struct k_thread *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_thread_priority_get, K_OBJ_THREAD,
+ struct k_thread *);
#endif
void _impl_k_thread_priority_set(k_tid_t tid, int prio)
@@ -375,16 +375,16 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_thread_priority_set, thread_p, prio)
+Z_SYSCALL_HANDLER(k_thread_priority_set, thread_p, prio)
{
struct k_thread *thread = (struct k_thread *)thread_p;
- _SYSCALL_OBJ(thread, K_OBJ_THREAD);
- _SYSCALL_VERIFY_MSG(_is_valid_prio(prio, NULL),
- "invalid thread priority %d", (int)prio);
- _SYSCALL_VERIFY_MSG((s8_t)prio >= thread->base.prio,
- "thread priority may only be downgraded (%d < %d)",
- prio, thread->base.prio);
+ Z_OOPS(Z_SYSCALL_OBJ(thread, K_OBJ_THREAD));
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(_is_valid_prio(prio, NULL),
+ "invalid thread priority %d", (int)prio));
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG((s8_t)prio >= thread->base.prio,
+ "thread priority may only be downgraded (%d < %d)",
+ prio, thread->base.prio));
_impl_k_thread_priority_set((k_tid_t)thread, prio);
return 0;
@@ -438,7 +438,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER0_SIMPLE_VOID(k_yield);
+Z_SYSCALL_HANDLER0_SIMPLE_VOID(k_yield);
#endif
void _impl_k_sleep(s32_t duration)
@@ -472,13 +472,13 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_sleep, duration)
+Z_SYSCALL_HANDLER(k_sleep, duration)
{
/* FIXME there were some discussions recently on whether we should
* relax this, thread would be unscheduled until k_wakeup issued
*/
- _SYSCALL_VERIFY_MSG(duration != K_FOREVER,
- "sleeping forever not allowed");
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(duration != K_FOREVER,
+ "sleeping forever not allowed"));
_impl_k_sleep(duration);
return 0;
@@ -510,7 +510,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_wakeup, K_OBJ_THREAD, k_tid_t);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_wakeup, K_OBJ_THREAD, k_tid_t);
#endif
k_tid_t _impl_k_current_get(void)
@@ -519,7 +519,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER0_SIMPLE(k_current_get);
+Z_SYSCALL_HANDLER0_SIMPLE(k_current_get);
#endif
#ifdef CONFIG_TIMESLICING
@@ -591,7 +591,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER0_SIMPLE(k_is_preempt_thread);
+Z_SYSCALL_HANDLER0_SIMPLE(k_is_preempt_thread);
#endif
#ifdef CONFIG_SMP
diff --git a/kernel/sem.c b/kernel/sem.c
index 3a93cb2..142f5c0 100644
--- a/kernel/sem.c
+++ b/kernel/sem.c
@@ -73,10 +73,10 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_sem_init, sem, initial_count, limit)
+Z_SYSCALL_HANDLER(k_sem_init, sem, initial_count, limit)
{
- _SYSCALL_OBJ_INIT(sem, K_OBJ_SEM);
- _SYSCALL_VERIFY(limit != 0 && initial_count <= limit);
+ Z_OOPS(Z_SYSCALL_OBJ_INIT(sem, K_OBJ_SEM));
+ Z_OOPS(Z_SYSCALL_VERIFY(limit != 0 && initial_count <= limit));
_impl_k_sem_init((struct k_sem *)sem, initial_count, limit);
return 0;
}
@@ -139,7 +139,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_sem_give, K_OBJ_SEM, struct k_sem *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_sem_give, K_OBJ_SEM, struct k_sem *);
#endif
int _impl_k_sem_take(struct k_sem *sem, s32_t timeout)
@@ -163,12 +163,12 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_sem_take, sem, timeout)
+Z_SYSCALL_HANDLER(k_sem_take, sem, timeout)
{
- _SYSCALL_OBJ(sem, K_OBJ_SEM);
+ Z_OOPS(Z_SYSCALL_OBJ(sem, K_OBJ_SEM));
return _impl_k_sem_take((struct k_sem *)sem, timeout);
}
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_sem_reset, K_OBJ_SEM, struct k_sem *);
-_SYSCALL_HANDLER1_SIMPLE(k_sem_count_get, K_OBJ_SEM, struct k_sem *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_sem_reset, K_OBJ_SEM, struct k_sem *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_sem_count_get, K_OBJ_SEM, struct k_sem *);
#endif
diff --git a/kernel/stack.c b/kernel/stack.c
index 77effa0..25e51aa 100644
--- a/kernel/stack.c
+++ b/kernel/stack.c
@@ -74,10 +74,10 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_stack_alloc_init, stack, num_entries)
+Z_SYSCALL_HANDLER(k_stack_alloc_init, stack, num_entries)
{
- _SYSCALL_OBJ_NEVER_INIT(stack, K_OBJ_STACK);
- _SYSCALL_VERIFY(num_entries > 0);
+ Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(stack, K_OBJ_STACK));
+ Z_OOPS(Z_SYSCALL_VERIFY(num_entries > 0));
_impl_k_stack_alloc_init((struct k_stack *)stack, num_entries);
return 0;
@@ -122,12 +122,13 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_stack_push, stack_p, data)
+Z_SYSCALL_HANDLER(k_stack_push, stack_p, data)
{
struct k_stack *stack = (struct k_stack *)stack_p;
- _SYSCALL_OBJ(stack, K_OBJ_STACK);
- _SYSCALL_VERIFY_MSG(stack->next != stack->top, "stack is full");
+ Z_OOPS(Z_SYSCALL_OBJ(stack, K_OBJ_STACK));
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(stack->next != stack->top,
+ "stack is full"));
_impl_k_stack_push(stack, data);
return 0;
@@ -162,10 +163,10 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_stack_pop, stack, data, timeout)
+Z_SYSCALL_HANDLER(k_stack_pop, stack, data, timeout)
{
- _SYSCALL_OBJ(stack, K_OBJ_STACK);
- _SYSCALL_MEMORY_WRITE(data, sizeof(u32_t));
+ Z_OOPS(Z_SYSCALL_OBJ(stack, K_OBJ_STACK));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, sizeof(u32_t)));
return _impl_k_stack_pop((struct k_stack *)stack, (u32_t *)data,
timeout);
diff --git a/kernel/sys_clock.c b/kernel/sys_clock.c
index 192fa8d..6c4afb4 100644
--- a/kernel/sys_clock.c
+++ b/kernel/sys_clock.c
@@ -79,10 +79,10 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_uptime_get_32)
+Z_SYSCALL_HANDLER(k_uptime_get_32)
{
#ifdef CONFIG_TICKLESS_KERNEL
- _SYSCALL_VERIFY(_sys_clock_always_on);
+ Z_OOPS(Z_SYSCALL_VERIFY(_sys_clock_always_on));
#endif
return _impl_k_uptime_get_32();
}
@@ -126,11 +126,11 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_uptime_get, ret_p)
+Z_SYSCALL_HANDLER(k_uptime_get, ret_p)
{
u64_t *ret = (u64_t *)ret_p;
- _SYSCALL_MEMORY_WRITE(ret, sizeof(*ret));
+ Z_OOPS(Z_SYSCALL_MEMORY_WRITE(ret, sizeof(*ret)));
*ret = _impl_k_uptime_get();
return 0;
}
diff --git a/kernel/thread.c b/kernel/thread.c
index 2c8863f..cdc074b 100644
--- a/kernel/thread.c
+++ b/kernel/thread.c
@@ -131,7 +131,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_thread_custom_data_set, data)
+Z_SYSCALL_HANDLER(k_thread_custom_data_set, data)
{
_impl_k_thread_custom_data_set((void *)data);
return 0;
@@ -144,7 +144,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER0_SIMPLE(k_thread_custom_data_get);
+Z_SYSCALL_HANDLER0_SIMPLE(k_thread_custom_data_get);
#endif /* CONFIG_USERSPACE */
#endif /* CONFIG_THREAD_CUSTOM_DATA */
@@ -224,7 +224,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_start, K_OBJ_THREAD, struct k_thread *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_start, K_OBJ_THREAD, struct k_thread *);
#endif
#endif
@@ -336,8 +336,8 @@
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_thread_create,
- new_thread_p, stack_p, stack_size, entry, p1, more_args)
+Z_SYSCALL_HANDLER(k_thread_create,
+ new_thread_p, stack_p, stack_size, entry, p1, more_args)
{
int prio;
u32_t options, delay;
@@ -352,12 +352,12 @@
k_thread_stack_t *stack = (k_thread_stack_t *)stack_p;
/* The thread and stack objects *must* be in an uninitialized state */
- _SYSCALL_OBJ_NEVER_INIT(new_thread, K_OBJ_THREAD);
+ Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(new_thread, K_OBJ_THREAD));
stack_object = _k_object_find(stack);
- _SYSCALL_VERIFY_MSG(!_obj_validation_check(stack_object, stack,
- K_OBJ__THREAD_STACK_ELEMENT,
- _OBJ_INIT_FALSE),
- "bad stack object");
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(!_obj_validation_check(stack_object, stack,
+ K_OBJ__THREAD_STACK_ELEMENT,
+ _OBJ_INIT_FALSE),
+ "bad stack object"));
#ifndef CONFIG_MPU_REQUIRES_POWER_OF_TWO_ALIGNMENT
/* Verify that the stack size passed in is OK by computing the total
@@ -368,20 +368,21 @@
* size and not allocated in addition to the stack size
*/
guard_size = (u32_t)K_THREAD_STACK_BUFFER(stack) - (u32_t)stack;
- _SYSCALL_VERIFY_MSG(!__builtin_uadd_overflow(guard_size, stack_size,
- &total_size),
- "stack size overflow (%u+%u)", stack_size,
- guard_size);
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(!__builtin_uadd_overflow(guard_size,
+ stack_size,
+ &total_size),
+ "stack size overflow (%u+%u)", stack_size,
+ guard_size));
#else
total_size = stack_size;
#endif
/* They really ought to be equal, make this more strict? */
- _SYSCALL_VERIFY_MSG(total_size <= stack_object->data,
- "stack size %u is too big, max is %u",
- total_size, stack_object->data);
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(total_size <= stack_object->data,
+ "stack size %u is too big, max is %u",
+ total_size, stack_object->data));
/* Verify the struct containing args 6-10 */
- _SYSCALL_MEMORY_READ(margs, sizeof(*margs));
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(margs, sizeof(*margs)));
/* Stash struct arguments in local variables to prevent switcheroo
* attacks
@@ -394,14 +395,15 @@
/* User threads may only create other user threads and they can't
* be marked as essential
*/
- _SYSCALL_VERIFY(options & K_USER);
- _SYSCALL_VERIFY(!(options & K_ESSENTIAL));
+ Z_OOPS(Z_SYSCALL_VERIFY(options & K_USER));
+ Z_OOPS(Z_SYSCALL_VERIFY(!(options & K_ESSENTIAL)));
/* Check validity of prio argument; must be the same or worse priority
* than the caller
*/
- _SYSCALL_VERIFY(_is_valid_prio(prio, NULL));
- _SYSCALL_VERIFY(_is_prio_lower_or_equal(prio, _current->base.prio));
+ Z_OOPS(Z_SYSCALL_VERIFY(_is_valid_prio(prio, NULL)));
+ Z_OOPS(Z_SYSCALL_VERIFY(_is_prio_lower_or_equal(prio,
+ _current->base.prio)));
_setup_new_thread((struct k_thread *)new_thread, stack, stack_size,
(k_thread_entry_t)entry, (void *)p1,
@@ -438,7 +440,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE(k_thread_cancel, K_OBJ_THREAD, struct k_thread *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_thread_cancel, K_OBJ_THREAD, struct k_thread *);
#endif
void _k_thread_single_suspend(struct k_thread *thread)
@@ -464,7 +466,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_suspend, K_OBJ_THREAD, k_tid_t);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_suspend, K_OBJ_THREAD, k_tid_t);
#endif
void _k_thread_single_resume(struct k_thread *thread)
@@ -483,7 +485,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_resume, K_OBJ_THREAD, k_tid_t);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_thread_resume, K_OBJ_THREAD, k_tid_t);
#endif
void _k_thread_single_abort(struct k_thread *thread)
diff --git a/kernel/thread_abort.c b/kernel/thread_abort.c
index 85fea8a..e3cc872 100644
--- a/kernel/thread_abort.c
+++ b/kernel/thread_abort.c
@@ -52,12 +52,12 @@
#endif
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_thread_abort, thread_p)
+Z_SYSCALL_HANDLER(k_thread_abort, thread_p)
{
struct k_thread *thread = (struct k_thread *)thread_p;
- _SYSCALL_OBJ(thread, K_OBJ_THREAD);
- _SYSCALL_VERIFY_MSG(!(thread->base.user_options & K_ESSENTIAL),
- "aborting essential thread %p", thread);
+ Z_OOPS(Z_SYSCALL_OBJ(thread, K_OBJ_THREAD));
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(!(thread->base.user_options & K_ESSENTIAL),
+ "aborting essential thread %p", thread));
_impl_k_thread_abort((struct k_thread *)thread);
return 0;
diff --git a/kernel/timer.c b/kernel/timer.c
index ea1ac6b..6b4a573 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -133,16 +133,16 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_timer_start, timer, duration_p, period_p)
+Z_SYSCALL_HANDLER(k_timer_start, timer, duration_p, period_p)
{
s32_t duration, period;
duration = (s32_t)duration_p;
period = (s32_t)period_p;
- _SYSCALL_VERIFY(duration >= 0 && period >= 0 &&
- (duration != 0 || period != 0));
- _SYSCALL_OBJ(timer, K_OBJ_TIMER);
+ Z_OOPS(Z_SYSCALL_VERIFY(duration >= 0 && period >= 0 &&
+ (duration != 0 || period != 0)));
+ Z_OOPS(Z_SYSCALL_OBJ(timer, K_OBJ_TIMER));
_impl_k_timer_start((struct k_timer *)timer, duration, period);
return 0;
}
@@ -178,7 +178,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE_VOID(k_timer_stop, K_OBJ_TIMER, struct k_timer *);
+Z_SYSCALL_HANDLER1_SIMPLE_VOID(k_timer_stop, K_OBJ_TIMER, struct k_timer *);
#endif
u32_t _impl_k_timer_status_get(struct k_timer *timer)
@@ -193,7 +193,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE(k_timer_status_get, K_OBJ_TIMER, struct k_timer *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_timer_status_get, K_OBJ_TIMER, struct k_timer *);
#endif
u32_t _impl_k_timer_status_sync(struct k_timer *timer)
@@ -225,7 +225,7 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE(k_timer_status_sync, K_OBJ_TIMER, struct k_timer *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_timer_status_sync, K_OBJ_TIMER, struct k_timer *);
#endif
s32_t _timeout_remaining_get(struct _timeout *timeout)
@@ -256,12 +256,12 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER1_SIMPLE(k_timer_remaining_get, K_OBJ_TIMER, struct k_timer *);
-_SYSCALL_HANDLER1_SIMPLE(k_timer_user_data_get, K_OBJ_TIMER, struct k_timer *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_timer_remaining_get, K_OBJ_TIMER, struct k_timer *);
+Z_SYSCALL_HANDLER1_SIMPLE(k_timer_user_data_get, K_OBJ_TIMER, struct k_timer *);
-_SYSCALL_HANDLER(k_timer_user_data_set, timer, user_data)
+Z_SYSCALL_HANDLER(k_timer_user_data_set, timer, user_data)
{
- _SYSCALL_OBJ(timer, K_OBJ_TIMER);
+ Z_OOPS(Z_SYSCALL_OBJ(timer, K_OBJ_TIMER));
_impl_k_timer_user_data_set((struct k_timer *)timer, (void *)user_data);
return 0;
}
diff --git a/kernel/userspace_handler.c b/kernel/userspace_handler.c
index 0866d1f..358474e 100644
--- a/kernel/userspace_handler.c
+++ b/kernel/userspace_handler.c
@@ -36,34 +36,36 @@
* To avoid double _k_object_find() lookups, we don't call the implementation
* function, but call a level deeper.
*/
-_SYSCALL_HANDLER(k_object_access_grant, object, thread)
+Z_SYSCALL_HANDLER(k_object_access_grant, object, thread)
{
struct _k_object *ko;
- _SYSCALL_OBJ_INIT(thread, K_OBJ_THREAD);
+ Z_OOPS(Z_SYSCALL_OBJ_INIT(thread, K_OBJ_THREAD));
ko = validate_any_object((void *)object);
- _SYSCALL_VERIFY_MSG(ko, "object %p access denied", (void *)object);
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(ko, "object %p access denied",
+ (void *)object));
_thread_perms_set(ko, (struct k_thread *)thread);
return 0;
}
-_SYSCALL_HANDLER(k_object_release, object)
+Z_SYSCALL_HANDLER(k_object_release, object)
{
struct _k_object *ko;
ko = validate_any_object((void *)object);
- _SYSCALL_VERIFY_MSG(ko, "object %p access denied", (void *)object);
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(ko, "object %p access denied",
+ (void *)object));
_thread_perms_clear(ko, _current);
return 0;
}
-_SYSCALL_HANDLER(k_object_alloc, otype)
+Z_SYSCALL_HANDLER(k_object_alloc, otype)
{
- _SYSCALL_VERIFY_MSG(otype > K_OBJ_ANY && otype < K_OBJ_LAST &&
- otype != K_OBJ__THREAD_STACK_ELEMENT,
- "bad object type %d requested", otype);
+ Z_OOPS(Z_SYSCALL_VERIFY_MSG(otype > K_OBJ_ANY && otype < K_OBJ_LAST &&
+ otype != K_OBJ__THREAD_STACK_ELEMENT,
+ "bad object type %d requested", otype));
return (u32_t)_impl_k_object_alloc(otype);
}
diff --git a/misc/printk.c b/misc/printk.c
index a1aa4be..e9ee67d 100644
--- a/misc/printk.c
+++ b/misc/printk.c
@@ -305,9 +305,9 @@
}
#ifdef CONFIG_USERSPACE
-_SYSCALL_HANDLER(k_str_out, c, n)
+Z_SYSCALL_HANDLER(k_str_out, c, n)
{
- _SYSCALL_MEMORY_READ(c, n);
+ Z_OOPS(Z_SYSCALL_MEMORY_READ(c, n));
_impl_k_str_out((char *)c, n);
return 0;
diff --git a/scripts/gen_kobject_list.py b/scripts/gen_kobject_list.py
index df4ab44..5e53db6 100755
--- a/scripts/gen_kobject_list.py
+++ b/scripts/gen_kobject_list.py
@@ -120,18 +120,17 @@
driver_macro_tpl = """
-#define _SYSCALL_DRIVER_%(driver_upper)s(ptr, op) _SYSCALL_DRIVER_GEN(ptr, op, %(driver_lower)s, %(driver_upper)s)
+#define Z_SYSCALL_DRIVER_%(driver_upper)s(ptr, op) Z_SYSCALL_DRIVER_GEN(ptr, op, %(driver_lower)s, %(driver_upper)s)
"""
def write_validation_output(fp):
fp.write("#ifndef __DRIVER_VALIDATION_GEN_H__\n")
fp.write("#define __DRIVER_VALIDATION_GEN_H__\n")
- fp.write("""#define _SYSCALL_DRIVER_GEN(ptr, op, driver_lower_case, driver_upper_case) \\
- do { \\
- _SYSCALL_OBJ(ptr, K_OBJ_DRIVER_##driver_upper_case); \\
- _SYSCALL_DRIVER_OP(ptr, driver_lower_case##_driver_api, op); \\
- } while (0)\n\n""");
+ fp.write("""#define Z_SYSCALL_DRIVER_GEN(ptr, op, driver_lower_case, driver_upper_case) \\
+ (Z_SYSCALL_OBJ(ptr, K_OBJ_DRIVER_##driver_upper_case) || \\
+ Z_SYSCALL_DRIVER_OP(ptr, driver_lower_case##_driver_api, op))
+ """)
for subsystem in subsystems:
subsystem = subsystem.replace("_driver_api", "")
