Obtaining Thread ID for all Zephyr Threads for Native-POSIX Linux board target

[bob2oneil]

For the Native-POSIX board target, I need to change the thread priorities of an application for all kthreads in the application, both threads I explicitly create and those created via kernel configuration.

I am able to enumerate through all threads in the application using the k_thread_foreach() API with a callback.

In the callback, I need to obtain the thread ID that is somewhat equivalent to the pthread_self() API that I use for the main thread, and then I use a Linux API on that thread ID to enhance the thread priority when executing under Linux to make the Native-POSIX application behave more real time.

Nominally, the Linux priority for all threads has a value of 20, which is not sufficient for pseudo real time behavior under Linux.

Obtaining this handle via the callback mechanism is not apparent through an API from the k_thread pointer.

My code looks something like the following, what is missing the Thread ID obtained in the callback.

I need an ID of the data type pthread_t to use with the standard Linux API pthread_setschedparam().

The use of k_thread pointer provided as an argument to the callback does not work.

k_thread_foreach(App::threadCallback, (void *)0);
    
void App::threadCallback(const struct k_thread *cthread, void *user_data)
{
    char state_str[32];

    struct k_thread *thread = (struct k_thread *)cthread;

    const char *tname = k_thread_name_get(thread);

    printk("%s%p %-10s\n",
           (thread == k_current_get()) ? "*" : " ",
           thread,
           tname ? tname : "NA");

    printk("\tID: %p, options: 0x%x, priority: %d timeout: %d\n",
           thread,
           thread->base.user_options,
           thread->base.prio,
           (int64_t)thread->base.timeout.dticks);

    printk("\tstate: %s, entry: %p\n",
           k_thread_state_str(thread, state_str, sizeof(state_str)),
           thread->entry.pEntry);

#ifdef CONFIG_ARCH_POSIX
    if (isRootUser())
    {
        int policy = SCHED_FIFO;
        uint32_t sched_priority = zephyr_to_posix_priority(thread->base.prio, &policy);

        printk("Changing thread '%s' Zephyr priority %d to Linux priority %d, policy %d\n", tname, thread->base.prio, policy);

        SysUtils::setThreadScheduleAndPriority((pthread_t)thread, sched_priority, policy);
    }
#endif
}

[ndrs-pst]

Hi @bob2oneil, I might be touching on something a bit different here, but since you're using Zephyr with native-posix, have you considered checking out their POSIX compatibility layer?
It could be really relevant to what you're doing. Here's a link to the docs: Zephyr POSIX Subsystem. Just a thought! 😊👍

[bob2oneil]

Thanks for the reply. I do have CONFIG_POSIX_API enabled in the kernel configuration when I target the Native-POSIX board target.

I am also using POSIX APIs in the application code wherever I can independent of board configurations.

However, I am using Zephyr's mechanisms for thread creation as described above, and can not get access to Zephyr kernel configuration based Zephyr thread creation, which are the 10 or say other threads on the application that I would need to change to Linux pthread based kernel priorities to achieve near real-time behavior on a standard Linux distro (without too much tuning).

[ndrs-pst]

@bob2oneil, does this include what you're looking for?

zephyr/arch/posix/core/thread.c

Lines 26 to 50 in 0a8d03b

	void arch_new_thread(struct k_thread *thread, k_thread_stack_t *stack,
	char *stack_ptr, k_thread_entry_t entry,
	void *p1, void *p2, void *p3)
	{
	posix_thread_status_t *thread_status;
	/* We store it in the same place where normal archs store the
	* "initial stack frame"
	*/
	thread_status = Z_STACK_PTR_TO_FRAME(posix_thread_status_t, stack_ptr);
	/* z_thread_entry() arguments */
	thread_status->entry_point = entry;
	thread_status->arg1 = p1;
	thread_status->arg2 = p2;
	thread_status->arg3 = p3;
	#if defined(CONFIG_ARCH_HAS_THREAD_ABORT)
	thread_status->aborted = 0;
	#endif
	thread->callee_saved.thread_status = thread_status;
	thread_status->thread_idx = posix_new_thread((void *)thread_status);
	}

zephyr/arch/posix/core/posix_core.c

Lines 357 to 383 in 0a8d03b

	int posix_new_thread(void *ptr)
	{
	int t_slot;
	t_slot = ttable_get_empty_slot();
	threads_table[t_slot].state = USED;
	threads_table[t_slot].running = false;
	threads_table[t_slot].thead_cnt = thread_create_count++;
	threads_table[t_slot].t_status = ptr;
	/*
	* Note: If you are here due to a valgrind reported memory leak in
	* pthread_create() please use the provided valgrind.supp suppression file.
	*/
	PC_SAFE_CALL(pthread_create(&threads_table[t_slot].thread,
	NULL,
	posix_thread_starter,
	(void *)(intptr_t)t_slot));
	PC_DEBUG("%s created thread [%i] %i [%lu]\n",
	__func__,
	threads_table[t_slot].thead_cnt,
	t_slot,
	threads_table[t_slot].thread);
	return t_slot;
	}

If you're using k_thread_create(), you might need to look into how to intercept the values return from pthread_create().