syscall: rename Z_SYSCALL_ to K_SYSCALL_

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(Z_SYSCALL_SPECIFIC_DRIVER(dev, K_OBJ_DRIVER_GENERIC, &api));
+       Z_OOPS(K_SYSCALL_SPECIFIC_DRIVER(dev, K_OBJ_DRIVER_GENERIC, &api));
        return z_impl_specific_do_that(dev, bar)
    }
 

doc/kernel/usermode/syscalls.rst

@@ -279,24 +279,24 @@ Argument Validation
 
 Several macros exist to validate arguments:
 
-* :c:macro:`Z_SYSCALL_OBJ()` Checks a memory address to assert that it is
+* :c:macro:`K_SYSCALL_OBJ()` Checks a memory address to assert that it is
   a valid kernel object of the expected type, that the calling thread
   has permissions on it, and that the object is initialized.
 
-* :c:macro:`Z_SYSCALL_OBJ_INIT()` is the same as
-  :c:macro:`Z_SYSCALL_OBJ()`, except that the provided object may be
+* :c:macro:`K_SYSCALL_OBJ_INIT()` is the same as
+  :c:macro:`K_SYSCALL_OBJ()`, except that the provided object may be
   uninitialized. This is useful for verifiers of object init functions.
 
-* :c:macro:`Z_SYSCALL_OBJ_NEVER_INIT()` is the same as
-  :c:macro:`Z_SYSCALL_OBJ()`, except that the provided object must be
+* :c:macro:`K_SYSCALL_OBJ_NEVER_INIT()` is the same as
+  :c:macro:`K_SYSCALL_OBJ()`, except that the provided object must be
   uninitialized. This is not used very often, currently only for
   :c:func:`k_thread_create()`.
 
-* :c:macro:`Z_SYSCALL_MEMORY_READ()` validates a memory buffer of a particular
+* :c:macro:`K_SYSCALL_MEMORY_READ()` validates a memory buffer of a particular
   size. The calling thread must have read permissions on the entire buffer.
 
-* :c:macro:`Z_SYSCALL_MEMORY_WRITE()` is the same as
-  :c:macro:`Z_SYSCALL_MEMORY_READ()` but the calling thread must additionally
+* :c:macro:`K_SYSCALL_MEMORY_WRITE()` is the same as
+  :c:macro:`K_SYSCALL_MEMORY_READ()` but the calling thread must additionally
   have write permissions.
 
 * :c:macro:`K_SYSCALL_MEMORY_ARRAY_READ()` validates an array whose total size
@@ -315,14 +315,14 @@ Several macros exist to validate arguments:
   a message parameter, instead printing the expression tested if it
   fails. The latter should only be used for the most obvious of tests.
 
-* :c:macro:`Z_SYSCALL_DRIVER_OP()` checks at runtime if a driver
+* :c:macro:`K_SYSCALL_DRIVER_OP()` checks at runtime if a driver
   instance is capable of performing a particular operation.  While this
   macro can be used by itself, it's mostly a building block for macros
   that are automatically generated for every driver subsystem.  For
   instance, to validate the GPIO driver, one could use the
   :c:macro:`Z_SYSCALL_DRIVER_GPIO()` macro.
 
-* :c:macro:`Z_SYSCALL_SPECIFIC_DRIVER()` is a runtime check to verify that
+* :c:macro:`K_SYSCALL_SPECIFIC_DRIVER()` is a runtime check to verify that
   a provided pointer is a valid instance of a specific device driver, that
   the calling thread has permissions on it, and that the driver has been
   initialized. It does this by checking the API structure pointer that
@@ -357,7 +357,7 @@ For example:
 
     static int z_vrfy_k_sem_take(struct k_sem *sem, int32_t timeout)
     {
-        Z_OOPS(Z_SYSCALL_OBJ(sem, K_OBJ_SEM));
+        Z_OOPS(K_SYSCALL_OBJ(sem, K_OBJ_SEM));
         return z_impl_k_sem_take(sem, timeout);
     }
     #include <syscalls/k_sem_take_mrsh.c>
@@ -411,7 +411,7 @@ It might be tempting to do something more concise:
 
     int z_vrfy_some_syscall(int *out_param)
     {
-        Z_OOPS(Z_SYSCALL_MEMORY_WRITE(out_param, sizeof(*out_param)));
+        Z_OOPS(K_SYSCALL_MEMORY_WRITE(out_param, sizeof(*out_param)));
         return z_impl_some_syscall(out_param);
     }
 
@@ -528,7 +528,7 @@ should never be used to verify if resource allocation has been successful.
 Finally, we must consider large data buffers. These represent areas of user
 memory which either have data copied out of, or copied into. It is permitted
 to pass these pointers to the implementation function directly. The caller's
-access to the buffer still must be validated with ``Z_SYSCALL_MEMORY`` APIs.
+access to the buffer still must be validated with ``K_SYSCALL_MEMORY`` APIs.
 The following constraints need to be met:
 
  * If the buffer is used by the implementation function to write data, such
@@ -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(Z_SYSCALL_MEMORY_WRITE(buf, size));
+        Z_OOPS(K_SYSCALL_MEMORY_WRITE(buf, size));
         return z_impl_get_data_from_kernel(buf, size);
     }
 
@@ -565,14 +565,14 @@ conventions are as follows:
    missing system calls are routed to :c:func:`handler_no_syscall()` which
    invokes :c:macro:`Z_OOPS()`.
 
-#. Any invalid access to memory found by the set of ``Z_SYSCALL_MEMORY`` APIs,
+#. 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
    appropriate permissions on the memory buffer or some size calculation
    overflowed.
 
 #. Most system calls take kernel object pointers as an argument, checked either
-   with one of the ``Z_SYSCALL_OBJ`` functions,  ``Z_SYSCALL_DRIVER_nnnnn``, or
+   with one of the ``K_SYSCALL_OBJ`` functions,  ``Z_SYSCALL_DRIVER_nnnnn``, or
    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
@@ -632,12 +632,12 @@ APIs
 Helper macros for creating system call verification functions are provided in
 :zephyr_file:`include/zephyr/internal/syscall_handler.h`:
 
-* :c:macro:`Z_SYSCALL_OBJ()`
-* :c:macro:`Z_SYSCALL_OBJ_INIT()`
-* :c:macro:`Z_SYSCALL_OBJ_NEVER_INIT()`
+* :c:macro:`K_SYSCALL_OBJ()`
+* :c:macro:`K_SYSCALL_OBJ_INIT()`
+* :c:macro:`K_SYSCALL_OBJ_NEVER_INIT()`
 * :c:macro:`Z_OOPS()`
-* :c:macro:`Z_SYSCALL_MEMORY_READ()`
-* :c:macro:`Z_SYSCALL_MEMORY_WRITE()`
+* :c:macro:`K_SYSCALL_MEMORY_READ()`
+* :c:macro:`K_SYSCALL_MEMORY_WRITE()`
 * :c:macro:`K_SYSCALL_MEMORY_ARRAY_READ()`
 * :c:macro:`K_SYSCALL_MEMORY_ARRAY_WRITE()`
 * :c:macro:`K_SYSCALL_VERIFY_MSG()`

drivers/adc/adc_handlers.c

@@ -41,7 +41,7 @@ static bool copy_sequence(struct adc_sequence *dst,
 		dst->options = options;
 	}
 
-	if (Z_SYSCALL_MEMORY_WRITE(dst->buffer, dst->buffer_size) != 0) {
+	if (K_SYSCALL_MEMORY_WRITE(dst->buffer, dst->buffer_size) != 0) {
 		printk("no access to buffer memory\n");
 		return false;
 	}
@@ -84,7 +84,7 @@ static inline int z_vrfy_adc_read_async(const struct device *dev,
 		Z_OOPS(K_SYSCALL_VERIFY_MSG(sequence.options->callback == NULL,
 			    "ADC sequence callbacks forbidden from user mode"));
 	}
-	Z_OOPS(Z_SYSCALL_OBJ(async, K_OBJ_POLL_SIGNAL));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_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(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_AUXDISPLAY));
 	return z_impl_auxdisplay_custom_command(dev, data);
 }
 #include <syscalls/auxdisplay_custom_command_mrsh.c>

drivers/bbram/bbram_handlers.c

@@ -9,47 +9,47 @@
 
 static inline int z_vrfy_bbram_check_invalid(const struct device *dev)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
 	return z_impl_bbram_check_invalid(dev);
 }
 #include <syscalls/bbram_check_invalid_mrsh.c>
 
 static inline int z_vrfy_bbram_check_standby_power(const struct device *dev)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
 	return z_impl_bbram_check_standby_power(dev);
 }
 #include <syscalls/bbram_check_standby_power_mrsh.c>
 
 static inline int z_vrfy_bbram_check_power(const struct device *dev)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
 	return z_impl_bbram_check_power(dev);
 }
 #include <syscalls/bbram_check_power_mrsh.c>
 
 static inline int z_vrfy_bbram_get_size(const struct device *dev, size_t *size)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
-	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(size, sizeof(size_t)));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_MEMORY_WRITE(size, sizeof(size_t)));
 	return z_impl_bbram_get_size(dev, size);
 }
 #include <syscalls/bbram_get_size_mrsh.c>
 
 static inline int z_vrfy_bbram_read(const struct device *dev, size_t offset,
 				    size_t size, uint8_t *data)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
-	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, size));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, size));
 	return z_impl_bbram_read(dev, offset, size, data);
 }
 #include <syscalls/bbram_read_mrsh.c>
 
 static inline int z_vrfy_bbram_write(const struct device *dev, size_t offset,
 				     size_t size, const uint8_t *data)
 {
-	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
-	Z_OOPS(Z_SYSCALL_MEMORY_READ(data, size));
+	Z_OOPS(K_SYSCALL_OBJ(dev, K_OBJ_DRIVER_BBRAM));
+	Z_OOPS(K_SYSCALL_MEMORY_READ(data, size));
 	return z_impl_bbram_write(dev, offset, size, data);
 }
 #include <syscalls/bbram_write_mrsh.c>

drivers/cache/cache_handlers.c

@@ -9,23 +9,23 @@
 
 static inline int z_vrfy_sys_cache_data_flush_range(void *addr, size_t size)
 {
-	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(addr, size));
+	Z_OOPS(K_SYSCALL_MEMORY_WRITE(addr, size));
 
 	return z_impl_sys_cache_data_flush_range(addr, size);
 }
 #include <syscalls/sys_cache_data_flush_range_mrsh.c>
 
 static inline int z_vrfy_sys_cache_data_invd_range(void *addr, size_t size)
 {
-	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(addr, size));
+	Z_OOPS(K_SYSCALL_MEMORY_WRITE(addr, size));
 
 	return z_impl_sys_cache_data_invd_range(addr, size);
 }
 #include <syscalls/sys_cache_data_invd_range_mrsh.c>
 
 static inline int z_vrfy_sys_cache_data_flush_and_invd_range(void *addr, size_t size)
 {
-	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(addr, size));
+	Z_OOPS(K_SYSCALL_MEMORY_WRITE(addr, size));
 
 	return z_impl_sys_cache_data_flush_and_invd_range(addr, size);
 }