sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
9d3148406c
nuttx/sched/wqueue/kwork_notifier.c

509 lines
14 KiB
C
Raw Normal View History

sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* sched/wqueue/kwork_notifier.c
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Copyright (C) 2018 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <unistd.h>
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
#include <string.h>
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
#include <sched.h>
#include <assert.h>
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
#include <nuttx/kmalloc.h>
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
#include <nuttx/semaphore.h>
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
#include <nuttx/wqueue.h>
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
#include "signal/signal.h"
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
#ifdef CONFIG_WQUEUE_NOTIFIER
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/****************************************************************************
* Private Types
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* The full allocated notification will hold additional information. The
* allocated notification information persist until the work is executed
* and must be freed using kmm_free() by the work.
*/
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
struct work_notifier_alloc_s
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
struct work_notifier_s info; /* The notification info */
struct work_s work; /* Used for scheduling the work */
};
/* This structure describes one notification list entry */
struct work_notifier_entry_s
{
FAR struct work_notifier_entry_s *flink;
FAR struct work_notifier_alloc_s *alloc; /* Allocated notification info copy */
int16_t key; /* Unique ID for the notification */
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
};
/****************************************************************************
* Private Data
****************************************************************************/
/* This is a statically allocated pool of notification structures */
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static struct work_notifier_entry_s
g_notifier_pool[CONFIG_WQUEUE_NOTIFIER_NWAITERS];
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* This is a list of free notification structures */
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static FAR struct work_notifier_entry_s *g_notifier_free;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* This is a singly linked list of pending notifications. When an event
* occurs available, *all* of the waiters for that event in this list will
* be signaled and the entry will be freed. If there are multiple waiters
* for some resource, then only the highest priority thread will get the
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* resource. Lower priority threads will need to call work_notifier_setup()
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
* once again.
*/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static FAR struct work_notifier_entry_s *g_notifier_pending;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* This semaphore is used as mutex to enforce mutually exclusive access to
* the notification data structures.
*/
static sem_t g_notifier_sem;
/* Used for lookup key generation */
static uint16_t g_notifier_key;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_alloc
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
* Allocate a notification structure by removing it from the free list.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static FAR struct work_notifier_entry_s *work_notifier_alloc(void)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
notifier = g_notifier_free;
if (notifier != NULL)
{
g_notifier_free = notifier->flink;
notifier->flink = NULL;
}
return notifier;
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_free
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
* Free a notification structure by returning it to the head of the free
* list.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static inline void
work_notifier_free(FAR struct work_notifier_entry_s *notifier)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
notifier->flink = g_notifier_free;
g_notifier_free = notifier;
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_find
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
* Given a unique key for notification, find the corresponding notification
* structure in the pending notification list.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static FAR struct work_notifier_entry_s *
work_notifier_find(int16_t key, FAR struct work_notifier_entry_s **pprev)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier;
FAR struct work_notifier_entry_s *prev;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* Find the entry matching this key in the g_notifier_pending list. */
for (prev = NULL, notifier = g_notifier_pending;
notifier != NULL;
prev = notifier, notifier = notifier->flink)
{
/* Is this the one we were looking for? */
if (notifier->key == key)
{
/* Return the previous entry if so requested */
if (pprev != NULL)
{
*pprev = prev;
}
return notifier;
}
}
return NULL;
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_key
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
* Generate a unique key for this notification.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
static int16_t work_notifier_key(void)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
int16_t key;
/* Loop until a unique key is generated */
do
{
if (g_notifier_key >= INT16_MAX)
{
g_notifier_key = 0;
}
key = (int16_t)++g_notifier_key;
}
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
while (work_notifier_find(key, NULL) != NULL);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
return key;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_initialize
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Set up the notification data structures for normal operation.
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
void work_notifier_initialize(void)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
int i;
/* Add each notification structure to the free list */
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
for (i = 0; i < CONFIG_WQUEUE_NOTIFIER_NWAITERS; i++)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier = &g_notifier_pool[i];
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* Add the pre-allocated notification to the head of the free list */
notifier->flink = g_notifier_free;
g_notifier_free = notifier;
}
/* Initialize the semaphore that enforces mutually exclusive access to the
* notification data structures.
*/
nxsem_init(&g_notifier_sem, 0, 1);
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_setup
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Set up to provide a notification when event is signaled.
sched/signal: In signal notification facility, use sigqueue() to notify vs. kill(). With sigqueue, we can pass more info (but still not enough).
2018-09-09 19:57:25 +02:00
*
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
* Input Parameters:
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* info - Describes the work notification.
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Returned Value:
* > 0 - The key which may be used later in a call to
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* work_notifier_teardown().
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
* == 0 - Not used (reserved for wrapper functions).
* < 0 - An unexpected error occurred and no signal will be sent. The
* returned value is a negated errno value that indicates the
* nature of the failure.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
int work_notifier_setup(FAR struct work_notifier_s *info)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
int ret;
/* Get exclusive access to the notifier data structures */
ret = nxsem_wait(&g_notifier_sem);
if (ret < 0)
{
return ret;
}
/* Allocate a new notification */
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier = work_notifier_alloc();
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
if (notifier == NULL)
{
ret = -ENOSPC;
}
else
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_alloc_s *alloc;
int16_t key;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* Duplicate the notification info */
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
alloc = kmm_malloc(sizeof(struct work_notifier_alloc_s));
if (alloc == NULL)
{
work_notifier_free(notifier);
return -ENOMEM;
}
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
memcpy(&alloc->info, info, sizeof(struct work_notifier_s));
/* Generate a unique key for this notification */
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
key = work_notifier_key();
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* Add the notification to the head of the pending list */
notifier->flink = g_notifier_pending;
notifier->alloc = alloc;
notifier->key = key;
g_notifier_pending = notifier;
ret = key;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
}
(void)nxsem_post(&g_notifier_sem);
return ret;
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_teardown
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Eliminate a notification previously setup by work_notifier_setup().
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
* This function should only be called if the notification should be
* aborted prior to the notification. The notification will automatically
* be torn down after the signal is sent.
*
* Input Parameters:
* key - The key value returned from a previous call to
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* work_notifier_setup().
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Returned Value:
* Zero (OK) is returned on success; a negated errno value is returned on
* any failure.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
int work_notifier_teardown(int key)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier;
FAR struct work_notifier_entry_s *prev;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
int ret;
/* Get exclusive access to the notifier data structures */
ret = nxsem_wait(&g_notifier_sem);
if (ret < 0)
{
return ret;
}
/* Find the entry matching this PID in the g_notifier_pending list. We
* assume that there is only one.
*/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
notifier = work_notifier_find(key, &prev);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
if (notifier == NULL)
{
/* There is no notification with this key in the pending list */
ret = -ENOENT;
}
else
{
/* Found it! Remove the notification from the pending list */
if (prev == NULL)
{
g_notifier_pending = notifier->flink;
}
else
{
prev->flink = notifier->flink;
}
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* Free the contained information */
DEBUGASSERT(notifier->alloc != NULL);
kmm_free(notifier->alloc);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* And return the notification to the free list */
work_notifier_free(notifier);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
ret = OK;
}
(void)nxsem_post(&g_notifier_sem);
return ret;
}
/****************************************************************************
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* Name: work_notifier_signal
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
*
* Description:
* An event has just occurred. Signal all threads waiting for that event.
*
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
* When an event of interest occurs, *all* of the workers waiting for this
* event will be executed. If there are multiple workers for a resource
* then only the first to execute will get the resource. Others will
* need to call work_notifier_setup() once again.
sched/signal: In signal notification facility, use sigqueue() to notify vs. kill(). With sigqueue, we can pass more info (but still not enough).
2018-09-09 19:57:25 +02:00
*
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
* Input Parameters:
* evtype - The type of the event that just occurred.
* qualifier - Event qualifier to distinguish different cases of the
* generic event type.
*
* Returned Value:
* None.
*
****************************************************************************/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
void work_notifier_signal(enum work_evtype_e evtype,
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
FAR void *qualifier)
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_entry_s *notifier;
FAR struct work_notifier_entry_s *prev;
FAR struct work_notifier_entry_s *next;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
int ret;
/* Get exclusive access to the notifier data structure */
ret = nxsem_wait(&g_notifier_sem);
while (ret < 0)
{
DEBUGASSERT(ret == -EINTR || ret == -ECANCELED);
}
/* Don't let any newly started threads block this thread until all of
* the notifications and been sent.
*/
sched_lock();
/* Process the notification at the head of the pending list until the
* pending list is empty */
/* Find the entry matching this key in the g_notifier_pending list. */
for (prev = NULL, notifier = g_notifier_pending;
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
notifier != NULL;
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
notifier = next)
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
FAR struct work_notifier_alloc_s *alloc;
FAR struct work_notifier_s *info;
sched/signal: In signal notification facility, use sigqueue() to notify vs. kill(). With sigqueue, we can pass more info (but still not enough).
2018-09-09 19:57:25 +02:00
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* Set up for the next time through the loop (in case the entry is
* removed from the list).
*/
next = notifier->flink;
/* Check if this is the a notification request for the event that
* just occurred.
*/
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
alloc = notifier->alloc;
DEBUGASSERT(alloc != NULL);
info = &alloc->info;
if (info->evtype == evtype && info->qualifier == qualifier)
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
{
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* Yes.. Remove the notification from the pending list */
if (prev == NULL)
{
g_notifier_pending = next;
}
else
{
prev->flink = next;
}
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
/* Schedule the work */
(void)work_queue(HPWORK, &alloc->work, info->worker, info, 0);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
/* Free the notification by returning it to the free list */
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
work_notifier_free(notifier);
sched/signal: Add a generic signal notification facility. Modify the custom IOB available notifier so that it is now just a wrapper around this generic signal notification. This generic signal notification faility will, eventually, be used to support network polling. Squashed commit of the following: mm/iob: The IOB available notifier is now just a wrapper around the common signal notifier. sched/signal: Add a generic signal notification facility. sched/signal/sig_evthread.c: More trivial naming changes. sched/signal: Rename nxsig_notification() to nxsig_evthread() to make forthcoming naming additions more consistent.
2018-09-09 16:32:37 +02:00
}
else
{
/* The entry was not removed, the current entry will be the
* next previous entry.
*/
prev = notifier;
}
}
sched_unlock();
(void)nxsem_post(&g_notifier_sem);
}
Signals were not a good choice of IPC to implement the poll function for several reasons: In order to handle the asynchrnous poll-related event, a substantial amount of state information is needed. Signals are only capable of passing minimal amounts of data. There are also complexities with performing kernel space signal handlers in kernel space code that is better to avoid. So, instead of signals, the equivalent logic was converted to run via a callback that executes on the high-priority work queue. Squashed commit of the following: Fix up some final compile isses. net/netdev: Convert the network down notification logic to use the new wqueue-based notification factility. net/udp: Convert the UDP readahead notification logic to use the new wqueue-based notification factility. net/tcp: Convert the TCP readahead notification logic to use the new wqueue-based notification factility. mm/iob: Convert the IOB notification logic to use the new wqueue-based notification factility. sched/wqueue: Signals are not good IPCs to support the target poll functionality for several reasons including the amount of data that can be passed with a signal and in the fact that in protected and kernel modes, user threads executing signal handlers in protected, kernel memory is problematic. Instead, convert the same logic to perform the notifications via function callback on the high priority work queue.
2018-09-09 23:01:44 +02:00
#endif /* CONFIG_WQUEUE_NOTIFIER */
Reference in New Issue Copy Permalink