kernel: sys_workq: add k_is_in_sys_work API

Add k_is_in_sys_work() API which returns true if the thread context
is the system workqueue thread and the thread is currently servicing
a work item. Useful for checking if blocking is safe or required in
the case of calling an API which uses the system work queue
internally.

Signed-off-by: Bjarki Arge Andreasen <bjarki.andreasen@nordicsemi.no>

Author: bjarki-andreasen

include/zephyr/kernel.h

@@ -1181,6 +1181,19 @@ void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
  */
 bool k_is_in_isr(void);
 
+/**
+ * @brief Determine if code is running from system work item
+ *
+ * This routine allows the caller to customize its actions, depending on
+ * whether it is running from a system workqueue item.
+ *
+ * @funcprops \isr_ok
+ *
+ * @return false if not invoked from a system workqueue item.
+ * @return true if invoked from a system workqueue item.
+ */
+bool k_is_in_sys_work(void);
+
 /**
  * @brief Determine if code is running in a preemptible thread.
  *

kernel/work.c

@@ -1175,3 +1175,9 @@ bool k_work_flush_delayable(struct k_work_delayable *dwork,
 }
 
 #endif /* CONFIG_SYS_CLOCK_EXISTS */
+
+bool k_is_in_sys_work(void)
+{
+	return k_current_get() == k_work_queue_thread_get(&k_sys_work_q) &&
+	       flag_test(&k_sys_work_q.flags, K_WORK_QUEUE_BUSY_BIT);
+}

subsys/bluetooth/host/att.c

@@ -732,7 +732,7 @@ static struct net_buf *bt_att_chan_create_pdu(struct bt_att_chan *chan, uint8_t
 	default: {
 		k_tid_t current_thread = k_current_get();
 
-		if (current_thread == k_work_queue_thread_get(&k_sys_work_q)) {
+		if (k_is_in_sys_work()) {
 			/* No blocking in the sysqueue. */
 			timeout = K_NO_WAIT;
 		} else if (current_thread == att_handle_rsp_thread) {

subsys/bluetooth/host/classic/hfp_ag.c

@@ -215,7 +215,7 @@ static struct bt_ag_tx *bt_ag_tx_alloc(void)
 	 * so if we're in the same workqueue but there are no immediate
 	 * contexts available, there's no chance we'll get one by waiting.
 	 */
-	if (k_current_get() == &k_sys_work_q.thread) {
+	if (k_is_in_sys_work()) {
 		return k_fifo_get(&ag_tx_free, K_NO_WAIT);
 	}
 

subsys/bluetooth/host/conn.c

@@ -1606,8 +1606,7 @@ struct net_buf *bt_conn_create_pdu_timeout(struct net_buf_pool *pool,
 	 */
 	__ASSERT_NO_MSG(!k_is_in_isr());
 
-	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) &&
-	    k_current_get() == k_work_queue_thread_get(&k_sys_work_q)) {
+	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) && k_is_in_sys_work()) {
 		LOG_WRN("Timeout discarded. No blocking in syswq.");
 		timeout = K_NO_WAIT;
 	}

subsys/bluetooth/host/hci_core.c

@@ -410,7 +410,7 @@ int bt_hci_cmd_send_sync(uint16_t opcode, struct net_buf *buf,
 	/* Since the commands are now processed in the syswq, we cannot suspend
 	 * and wait. We have to send the command from the current context.
 	 */
-	if (k_current_get() == &k_sys_work_q.thread) {
+	if (k_is_in_sys_work()) {
 		/* drain the command queue until we get to send the command of interest. */
 		struct net_buf *cmd = NULL;
 

subsys/bluetooth/host/l2cap.c

@@ -674,8 +674,7 @@ struct net_buf *bt_l2cap_create_pdu_timeout(struct net_buf_pool *pool,
 					    size_t reserve,
 					    k_timeout_t timeout)
 {
-	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) &&
-	    k_current_get() == k_work_queue_thread_get(&k_sys_work_q)) {
+	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) && k_is_in_sys_work()) {
 		timeout = K_NO_WAIT;
 	}
 

subsys/input/input.c

@@ -52,8 +52,7 @@ int input_report(const struct device *dev,
 #ifdef CONFIG_INPUT_MODE_THREAD
 	int ret;
 
-	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) &&
-	    k_current_get() == k_work_queue_thread_get(&k_sys_work_q)) {
+	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT) && k_is_in_sys_work()) {
 		LOG_DBG("Timeout discarded. No blocking in syswq.");
 		timeout = K_NO_WAIT;
 	}

tests/bluetooth/host/conn/mocks/kernel.c

@@ -31,5 +31,6 @@ DEFINE_FAKE_VALUE_FUNC(void *, k_heap_alloc, struct k_heap *, size_t, k_timeout_
 DEFINE_FAKE_VOID_FUNC(k_heap_free, struct k_heap *, void *);
 DEFINE_FAKE_VOID_FUNC(k_sched_lock);
 DEFINE_FAKE_VOID_FUNC(k_sched_unlock);
+DEFINE_FAKE_VALUE_FUNC(bool, k_is_in_sys_work);
 
 struct k_work_q k_sys_work_q;

tests/bluetooth/host/conn/mocks/kernel.h

@@ -32,6 +32,7 @@
 	FAKE(k_heap_free)                                                                          \
 	FAKE(k_sched_lock)                                                                         \
 	FAKE(k_sched_unlock)                                                                       \
+	FAKE(k_is_in_sys_work)                                                                       \
 
 DECLARE_FAKE_VALUE_FUNC(bool, k_is_in_isr);
 DECLARE_FAKE_VALUE_FUNC(int, k_poll_signal_raise, struct k_poll_signal *, int);
@@ -56,3 +57,4 @@ DECLARE_FAKE_VALUE_FUNC(void *, k_heap_alloc, struct k_heap *, size_t, k_timeout
 DECLARE_FAKE_VOID_FUNC(k_heap_free, struct k_heap *, void *);
 DECLARE_FAKE_VOID_FUNC(k_sched_lock);
 DECLARE_FAKE_VOID_FUNC(k_sched_unlock);
+DECLARE_FAKE_VALUE_FUNC(bool, k_is_in_sys_work);