syscall: rename Z_OOPS -> K_OOPS

Rename internal API to not use z_/Z_.

Signed-off-by: Anas Nashif <anas.nashif@intel.com>

Author: nashif

doc/kernel/drivers/index.rst

@@ -239,7 +239,7 @@ implementation of both the subsystem API and the specific APIs:
 
    int z_vrfy_specific_from_user(const struct device *dev, int bar)
    {
-       Z_OOPS(K_SYSCALL_SPECIFIC_DRIVER(dev, K_OBJ_DRIVER_GENERIC, &api));
+       K_OOPS(K_SYSCALL_SPECIFIC_DRIVER(dev, K_OBJ_DRIVER_GENERIC, &api));
        return z_impl_specific_do_that(dev, bar)
    }
 

doc/kernel/usermode/syscalls.rst

@@ -331,7 +331,7 @@ Several macros exist to validate arguments:
   API structure.
 
 If any check fails, the macros will return a nonzero value. The macro
-:c:macro:`Z_OOPS()` can be used to induce a kernel oops which will kill the
+:c:macro:`K_OOPS()` can be used to induce a kernel oops which will kill the
 calling thread. This is done instead of returning some error condition to
 keep the APIs the same when calling from supervisor mode.
 
@@ -357,7 +357,7 @@ For example:
 
     static int z_vrfy_k_sem_take(struct k_sem *sem, int32_t timeout)
     {
-        Z_OOPS(K_SYSCALL_OBJ(sem, K_OBJ_SEM));
+        K_OOPS(K_SYSCALL_OBJ(sem, K_OBJ_SEM));
         return z_impl_k_sem_take(sem, timeout);
     }
     #include <syscalls/k_sem_take_mrsh.c>
@@ -397,7 +397,7 @@ for some integral value:
         int ret;
 
         ret = z_impl_some_syscall(&local_out_param);
-        Z_OOPS(k_usermode_to_copy(out_param, &local_out_param, sizeof(*out_param)));
+        K_OOPS(k_usermode_to_copy(out_param, &local_out_param, sizeof(*out_param)));
         return ret;
     }
 
@@ -411,7 +411,7 @@ It might be tempting to do something more concise:
 
     int z_vrfy_some_syscall(int *out_param)
     {
-        Z_OOPS(K_SYSCALL_MEMORY_WRITE(out_param, sizeof(*out_param)));
+        K_OOPS(K_SYSCALL_MEMORY_WRITE(out_param, sizeof(*out_param)));
         return z_impl_some_syscall(out_param);
     }
 
@@ -433,9 +433,9 @@ bytes processed. This too should use a stack copy:
         size_t size;
         int ret;
 
-        Z_OOPS(k_usermode_from_copy(&size, size_ptr, sizeof(size));
+        K_OOPS(k_usermode_from_copy(&size, size_ptr, sizeof(size));
         ret = z_impl_in_out_syscall(&size);
-        Z_OOPS(k_usermode_to_copy(size_ptr, &size, sizeof(size)));
+        K_OOPS(k_usermode_to_copy(size_ptr, &size, sizeof(size)));
         return ret;
     }
 
@@ -461,11 +461,11 @@ be copied. Typically this is done by allocating copies on the stack:
         struct bar bar_right_copy;
         struct bar bar_left_copy;
 
-        Z_OOPS(k_usermode_from_copy(&foo_copy, foo, sizeof(*foo)));
-        Z_OOPS(k_usermode_from_copy(&bar_right_copy, foo_copy.bar_right,
+        K_OOPS(k_usermode_from_copy(&foo_copy, foo, sizeof(*foo)));
+        K_OOPS(k_usermode_from_copy(&bar_right_copy, foo_copy.bar_right,
                                 sizeof(struct bar)));
         foo_copy.bar_right = &bar_right_copy;
-        Z_OOPS(k_usermode_from_copy(&bar_left_copy, foo_copy.bar_left,
+        K_OOPS(k_usermode_from_copy(&bar_left_copy, foo_copy.bar_left,
                                 sizeof(struct bar)));
         foo_copy.bar_left = &bar_left_copy;
 
@@ -478,7 +478,7 @@ memory from the caller's resource pool via :c:func:`z_thread_malloc()`. This
 should always be considered last resort. Functional safety programming
 guidelines heavily discourage usage of heap and the fact that a resource pool is
 used must be clearly documented. Any issues with allocation must be
-reported, to a caller, with returning the ``-ENOMEM`` . The ``Z_OOPS()``
+reported, to a caller, with returning the ``-ENOMEM`` . The ``K_OOPS()``
 should never be used to verify if resource allocation has been successful.
 
 .. code-block:: c
@@ -500,7 +500,7 @@ should never be used to verify if resource allocation has been successful.
         size_t bar_list_bytes;
 
         /* Safely copy foo into foo_copy */
-        Z_OOPS(k_usermode_from_copy(&foo_copy, foo, sizeof(*foo)));
+        K_OOPS(k_usermode_from_copy(&foo_copy, foo, sizeof(*foo)));
 
         /* Bounds check the count member, in the copy we made */
         if (foo_copy.count > 32) {
@@ -514,7 +514,7 @@ should never be used to verify if resource allocation has been successful.
         if (bar_list_copy == NULL) {
             return -ENOMEM;
         }
-        Z_OOPS(k_usermode_from_copy(bar_list_copy, foo_copy.bar_list,
+        K_OOPS(k_usermode_from_copy(bar_list_copy, foo_copy.bar_list,
                                 bar_list_bytes));
         foo_copy.bar_list = bar_list_copy;
 
@@ -549,7 +549,7 @@ The following constraints need to be met:
 
     int z_vrfy_get_data_from_kernel(void *buf, size_t size)
     {
-        Z_OOPS(K_SYSCALL_MEMORY_WRITE(buf, size));
+        K_OOPS(K_SYSCALL_MEMORY_WRITE(buf, size));
         return z_impl_get_data_from_kernel(buf, size);
     }
 
@@ -558,16 +558,16 @@ Verification Return Value Policies
 
 When verifying system calls, it's important to note which kinds of verification
 failures should propagate a return value to the caller, and which should
-simply invoke :c:macro:`Z_OOPS()` which kills the calling thread. The current
+simply invoke :c:macro:`K_OOPS()` which kills the calling thread. The current
 conventions are as follows:
 
 #. For system calls that are defined but not compiled, invocations of these
    missing system calls are routed to :c:func:`handler_no_syscall()` which
-   invokes :c:macro:`Z_OOPS()`.
+   invokes :c:macro:`K_OOPS()`.
 
 #. Any invalid access to memory found by the set of ``K_SYSCALL_MEMORY`` APIs,
    :c:func:`k_usermode_from_copy()`, :c:func:`k_usermode_to_copy()`
-   should trigger a :c:macro:`Z_OOPS`. This happens when the caller doesn't have
+   should trigger a :c:macro:`K_OOPS`. This happens when the caller doesn't have
    appropriate permissions on the memory buffer or some size calculation
    overflowed.
 
@@ -576,7 +576,7 @@ conventions are as follows:
    manually using :c:func:`k_object_validate()`. These can fail for a variety
    of reasons: missing driver API, bad kernel object pointer, wrong kernel
    object type, or improper initialization state. These issues should always
-   invoke :c:macro:`Z_OOPS()`.
+   invoke :c:macro:`K_OOPS()`.
 
 #. Any error resulting from a failed memory heap allocation, often from
    invoking :c:func:`z_thread_malloc()`, should propagate ``-ENOMEM`` to the
@@ -594,7 +594,7 @@ conventions are as follows:
    be registered from user mode. APIs which simply install callbacks shall not
    be exposed as system calls. Some driver subsystem APIs may take optional
    function callback pointers. User mode verification functions for these APIs
-   must enforce that these are NULL and should invoke :c:macro:`Z_OOPS()` if
+   must enforce that these are NULL and should invoke :c:macro:`K_OOPS()` if
    not.
 
 #. Some parameter checks are enforced only from user mode. These should be
@@ -608,14 +608,14 @@ There are some known exceptions to these policies currently in Zephyr:
   initialization bit pulls double-duty to indicate whether a thread is
   running, cleared upon exit. See #23030.
 
-* :c:func:`k_thread_create()` invokes :c:macro:`Z_OOPS()` for parameter
+* :c:func:`k_thread_create()` invokes :c:macro:`K_OOPS()` for parameter
   checks, due to a great deal of existing code ignoring the return value.
   This will also be addressed by #23030.
 
-* :c:func:`k_thread_abort()` invokes :c:macro:`Z_OOPS()` if an essential
+* :c:func:`k_thread_abort()` invokes :c:macro:`K_OOPS()` if an essential
   thread is aborted, as the function has no return value.
 
-* Various system calls related to logging invoke :c:macro:`Z_OOPS()`
+* Various system calls related to logging invoke :c:macro:`K_OOPS()`
   when bad parameters are passed in as they do not propagate errors.
 
 Configuration Options
@@ -635,7 +635,7 @@ Helper macros for creating system call verification functions are provided in
 * :c:macro:`K_SYSCALL_OBJ()`
 * :c:macro:`K_SYSCALL_OBJ_INIT()`
 * :c:macro:`K_SYSCALL_OBJ_NEVER_INIT()`
-* :c:macro:`Z_OOPS()`
+* :c:macro:`K_OOPS()`
 * :c:macro:`K_SYSCALL_MEMORY_READ()`
 * :c:macro:`K_SYSCALL_MEMORY_WRITE()`
 * :c:macro:`K_SYSCALL_MEMORY_ARRAY_READ()`

drivers/adc/adc_handlers.c

@@ -13,8 +13,8 @@ static inline int z_vrfy_adc_channel_setup(const struct device *dev,
 {
 	struct adc_channel_cfg channel_cfg;
 
-	Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, channel_setup));
-	Z_OOPS(k_usermode_from_copy(&channel_cfg,
+	K_OOPS(K_SYSCALL_DRIVER_ADC(dev, channel_setup));
+	K_OOPS(k_usermode_from_copy(&channel_cfg,
 				(struct adc_channel_cfg *)user_channel_cfg,
 				sizeof(struct adc_channel_cfg)));
 
@@ -55,12 +55,12 @@ static inline int z_vrfy_adc_read(const struct device *dev,
 	struct adc_sequence sequence;
 	struct adc_sequence_options options;
 
-	Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, read));
-	Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
+	K_OOPS(K_SYSCALL_DRIVER_ADC(dev, read));
+	K_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
 					(struct adc_sequence *)user_sequence),
 				    "invalid ADC sequence"));
 	if (sequence.options != NULL) {
-		Z_OOPS(K_SYSCALL_VERIFY_MSG(sequence.options->callback == NULL,
+		K_OOPS(K_SYSCALL_VERIFY_MSG(sequence.options->callback == NULL,
 			    "ADC sequence callbacks forbidden from user mode"));
 	}
 
@@ -76,15 +76,15 @@ static inline int z_vrfy_adc_read_async(const struct device *dev,
 	struct adc_sequence sequence;
 	struct adc_sequence_options options;
 
-	Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, read_async));
-	Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
+	K_OOPS(K_SYSCALL_DRIVER_ADC(dev, read_async));
+	K_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
 					(struct adc_sequence *)user_sequence),
 				    "invalid ADC sequence"));
 	if (sequence.options != NULL) {
-		Z_OOPS(K_SYSCALL_VERIFY_MSG(sequence.options->callback == NULL,
+		K_OOPS(K_SYSCALL_VERIFY_MSG(sequence.options->callback == NULL,
 			    "ADC sequence callbacks forbidden from user mode"));
 	}
-	Z_OOPS(K_SYSCALL_OBJ(async, K_OBJ_POLL_SIGNAL));
+	K_OOPS(K_SYSCALL_OBJ(async, K_OBJ_POLL_SIGNAL));
 
 	return z_impl_adc_read_async((const struct device *)dev, &sequence,
 				     (struct k_poll_signal *)async);

drivers/auxdisplay/auxdisplay_handlers.c

@@ -9,37 +9,37 @@
 
 static inline int z_vrfy_auxdisplay_display_on(const struct device *dev)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_display_on(dev);
 }
 #include <syscalls/auxdisplay_display_on_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_display_off(const struct device *dev)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_display_off(dev);
 }
 #include <syscalls/auxdisplay_display_off_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_cursor_set_enabled(const struct device *dev, bool enabled)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_cursor_set_enabled(dev, enabled);
 }
 #include <syscalls/auxdisplay_cursor_set_enabled_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_position_blinking_set_enabled(const struct device *dev,
 								  bool enabled)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_position_blinking_set_enabled(dev, enabled);
 }
 #include <syscalls/auxdisplay_position_blinking_set_enabled_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_cursor_shift_set(const struct device *dev, uint8_t direction,
 						     bool display_shift)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_cursor_shift_set(dev, direction, display_shift);
 }
 #include <syscalls/auxdisplay_cursor_shift_set_mrsh.c>
@@ -48,15 +48,15 @@ static inline int z_vrfy_auxdisplay_cursor_position_set(const struct device *dev
 							enum auxdisplay_position type,
 							int16_t x, int16_t y)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_cursor_position_set(dev, type, x, y);
 }
 #include <syscalls/auxdisplay_cursor_position_set_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_cursor_position_get(const struct device *dev, int16_t *x,
 							int16_t *y)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_cursor_position_get(dev, x,  y);
 }
 #include <syscalls/auxdisplay_cursor_position_get_mrsh.c>
@@ -65,93 +65,93 @@ static inline int z_vrfy_auxdisplay_display_position_set(const struct device *de
 							 enum auxdisplay_position type,
 							 int16_t x, int16_t y)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_display_position_set(dev, type, x, y);
 }
 #include <syscalls/auxdisplay_display_position_set_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_display_position_get(const struct device *dev, int16_t *x,
 							 int16_t *y)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_display_position_get(dev, x, y);
 }
 #include <syscalls/auxdisplay_display_position_get_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_capabilities_get(const struct device *dev,
 						struct auxdisplay_capabilities *capabilities)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_capabilities_get(dev, capabilities);
 }
 #include <syscalls/auxdisplay_capabilities_get_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_clear(const struct device *dev)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_clear(dev);
 }
 #include <syscalls/auxdisplay_clear_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_brightness_get(const struct device *dev,
 						   uint8_t *brightness)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_brightness_get(dev, brightness);
 }
 #include <syscalls/auxdisplay_brightness_get_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_brightness_set(const struct device *dev,
 						   uint8_t brightness)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_brightness_set(dev, brightness);
 }
 #include <syscalls/auxdisplay_brightness_set_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_backlight_get(const struct device *dev,
 						  uint8_t *backlight)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_backlight_get(dev, backlight);
 }
 #include <syscalls/auxdisplay_backlight_get_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_backlight_set(const struct device *dev,
 						  uint8_t backlight)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_backlight_set(dev, backlight);
 }
 #include <syscalls/auxdisplay_backlight_set_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_is_busy(const struct device *dev)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_is_busy(dev);
 }
 #include <syscalls/auxdisplay_is_busy_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_custom_character_set(const struct device *dev,
 							 struct auxdisplay_character *character)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_custom_character_set(dev, character);
 }
 #include <syscalls/auxdisplay_custom_character_set_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_write(const struct device *dev, const uint8_t *data,
 					  uint16_t len)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_write(dev, data, len);
 }
 #include <syscalls/auxdisplay_write_mrsh.c>
 
 static inline int z_vrfy_auxdisplay_custom_command(const struct device *dev,
 						   struct auxdisplay_custom_data *data)
 {
-	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	K_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_custom_command(dev, data);
 }
 #include <syscalls/auxdisplay_custom_command_mrsh.c>