sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
441b03c61c
nuttx/net/udp/udp_notifier.c

238 lines
8.0 KiB
C
Raw Normal View History

net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
/****************************************************************************
* net/udp/udp_notifier.c
*
net: Author Gregory Nutt: update licenses to Apache Gregory Nutt has submitted the SGA and we can migrate the licenses to Apache. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-02-19 12:45:37 +01:00
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
net: Author Gregory Nutt: update licenses to Apache Gregory Nutt has submitted the SGA and we can migrate the licenses to Apache. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-02-19 12:45:37 +01:00
* http://www.apache.org/licenses/LICENSE-2.0
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
net: Author Gregory Nutt: update licenses to Apache Gregory Nutt has submitted the SGA and we can migrate the licenses to Apache. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-02-19 12:45:37 +01:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.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 <assert.h>
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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
#include <nuttx/wqueue.h>
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
#include <nuttx/mm/iob.h>
#include "udp/udp.h"
Squashed commit of the following: Author: Gregory Nutt <gnutt@nuttx.org> Run all .h and .c files modified in last PR through nxstyle. Author: Xiang Xiao <xiaoxiang@xiaomi.com> Net cleanup (#17) * Fix the semaphore usage issue found in tcp/udp 1. The count semaphore need disable priority inheritance 2. Loop again if net_lockedwait return -EINTR 3. Call nxsem_trywait to avoid the race condition 4. Call nxsem_post instead of sem_post * Put the work notifier into free list to avoid the heap fragment in the long run. Since the allocation strategy is encapsulated internally, we can even refine the implementation later. * Network stack shouldn't allocate memory in the poll implementation to avoid the heap fragment in the long run, other modification include: 1. Select MM_IOB automatically since ICMP[v6] socket can't work without the read ahead buffer 2. Remove the net lock since xxx_callback_free already do the same thing 3. TCP/UDP poll should work even the read ahead buffer isn't enabled at all * Add NET_ prefix for UDP_NOTIFIER and TCP_NOTIFIER option to align with other UDP/TCP option convention * Remove the unused _SF_[IDLE|ACCEPT|SEND|RECV|MASK] flags since there are code to set/clear these flags, but nobody check them.
2019-12-31 16:26:14 +01:00
#ifdef CONFIG_NET_UDP_NOTIFIER
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
* Name: udp_readahead_notifier_setup
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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 perform a callback to the worker function when an UDP data
* is added to the read-ahead buffer. The worker function will execute
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
* on the low priority worker thread.
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
*
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
* Input Parameters:
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
* worker - The worker function to execute on the low priority work
* queue when data is available in the UDP read-ahead buffer.
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
* conn - The UDP connection where read-ahead data is needed.
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
* arg - A user-defined argument that will be available to the worker
* function when it runs.
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
* Returned Value:
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
* > 0 - The notification is in place. The returned value is a key that
* may be used later in a call to udp_notifier_teardown().
* == 0 - There is already buffered read-ahead data. No notification
* will be provided.
* < 0 - An unexpected error occurred and notification will occur. The
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
* returned value is a negated errno value that indicates the
* nature of the failure.
*
****************************************************************************/
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
int udp_readahead_notifier_setup(worker_t worker,
FAR struct udp_conn_s *conn,
FAR void *arg)
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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;
DEBUGASSERT(worker != NULL);
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
/* If there is already buffered read-ahead data, then return zero without
* setting up the notification.
*/
if (conn->readahead.qh_head != NULL)
{
return 0;
}
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
/* Otherwise, this is just a simple wrapper around work_notifer_setup(). */
info.evtype = WORK_UDP_READAHEAD;
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
info.qid = LPWORK;
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.qualifier = conn;
info.arg = arg;
info.worker = worker;
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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
return work_notifier_setup(&info);
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
}
/****************************************************************************
* Name: udp_writebuffer_notifier_setup
*
* Description:
* Set up to perform a callback to the worker function when an UDP write
* buffer is emptied. The worker function will execute on the high
* priority worker thread.
*
* Input Parameters:
* worker - The worker function to execute on the low priority work
* queue when data is available in the UDP read-ahead buffer.
* conn - The UDP connection where read-ahead data is needed.
* arg - A user-defined argument that will be available to the worker
* function when it runs.
*
* Returned Value:
* > 0 - The notification is in place. The returned value is a key that
* may be used later in a call to udp_notifier_teardown().
* == 0 - There is already buffered read-ahead data. No notification
* will be provided.
* < 0 - An unexpected error occurred and no notification will occur.
* The returned value is a negated errno value that indicates the
* nature of the failure.
*
****************************************************************************/
int udp_writebuffer_notifier_setup(worker_t worker,
FAR struct udp_conn_s *conn,
FAR void *arg)
{
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
struct work_notifier_s info;
DEBUGASSERT(worker != NULL);
/* If there is already buffered read-ahead data, then return zero without
* setting up the notification.
*/
if (sq_empty(&conn->write_q))
{
return 0;
}
/* Otherwise, this is just a simple wrapper around work_notifer_setup(). */
info.evtype = WORK_UDP_WRITEBUFFER;
info.qid = LPWORK;
info.qualifier = conn;
info.arg = arg;
info.worker = worker;
return work_notifier_setup(&info);
#else
return 0;
#endif
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
}
/****************************************************************************
* Name: udp_notifier_teardown
*
* Description:
* Eliminate a UDP read-ahead notification previously setup by
net: nxstyle fixes Nxstyle fixes to pass CI. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-02-19 15:01:46 +01:00
* udp_readahead_notifier_setup(). This function should only be called if
* the notification should be aborted prior to the notification. The
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
* notification will automatically be torn down after the notification.
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
* Input Parameters:
* key - The key value returned from a previous call to
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
* udp_readahead_notifier_setup().
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
* Returned Value:
* Zero (OK) is returned on success; a negated errno value is returned on
* any failure.
*
****************************************************************************/
int udp_notifier_teardown(int 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
/* This is just a simple wrapper around work_notifier_teardown(). */
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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
return work_notifier_teardown(key);
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
}
/****************************************************************************
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
* Name: udp_readahead_signal
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
*
* Description:
mm/iob: IOB free notifier should accept the work queue ID as a paramter. The notification may need to run on either the high- or low- priority work queue. sched/work: Change the default priority of the low-priority work queue to 100.
2018-09-11 16:49:39 +02:00
* Read-ahead data has been buffered. Notify all threads waiting for
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
* read-ahead data to become available.
*
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 read-ahead data becomes available, *all* of the workers waiting
* for read-ahead data will be executed. If there are multiple workers
* waiting for read-ahead data then only the first to execute will get the
net: nxstyle fixes Nxstyle fixes to pass CI. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-02-19 15:01:46 +01:00
* data.
* Others will need to call udp_readahead_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
*
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
* Input Parameters:
* conn - The UDP connection where read-ahead data was just buffered.
*
* Returned Value:
* None.
*
****************************************************************************/
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
void udp_readahead_signal(FAR struct udp_conn_s *conn)
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +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
/* This is just a simple wrapper around work_notifier_signal(). */
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
wqueue/notifier: update the work notifier usage usage changed after commit 90c52e6f8f7efce97ac718c0f98addc13ec880d2 Change-Id: Ifb0d739b046a6794b5b3ac177f489fb9a1c5c799 Signed-off-by: chao.an <anchao@xiaomi.com>
2020-01-19 10:44:27 +01:00
work_notifier_signal(WORK_UDP_READAHEAD, conn);
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
}
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
/****************************************************************************
* Name: udp_writebuffer_signal
*
* Description:
* All buffer Tx data has been sent. Signal all threads waiting for the
* write buffers to become empty.
*
* When write buffer becomes empty, *all* of the workers waiting
* for that event data will be executed. If there are multiple workers
* waiting for read-ahead data then only the first to execute will get the
* data. Others will need to call tcp_writebuffer_notifier_setup() once
* again.
*
* Input Parameters:
* conn - The UDP connection where read-ahead data was just buffered.
*
* Returned Value:
* None.
*
****************************************************************************/
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
void udp_writebuffer_signal(FAR struct udp_conn_s *conn)
{
/* This is just a simple wrapper around work_notifier_signal(). */
wqueue/notifier: update the work notifier usage usage changed after commit 90c52e6f8f7efce97ac718c0f98addc13ec880d2 Change-Id: Ifb0d739b046a6794b5b3ac177f489fb9a1c5c799 Signed-off-by: chao.an <anchao@xiaomi.com>
2020-01-19 10:44:27 +01:00
work_notifier_signal(WORK_UDP_WRITEBUFFER, conn);
This commit implements a proper version of SO_LINGER. Not sufficiently tested on initial commit. Squashed commit of the following: net/: Fix some naming inconsistencies, Fix final compilation issies. net/inet/inet_close(): Now that we have logic to drain the buffered TX data, we can implement a proper lingering close. net/inet,tcp,udp: Add functions to wait for write buffers to drain. net/udp: Add support for notification when the UDP write buffer becomes empty. net/tcp: Add support for notification when the TCP write buffer becomes empty.
2019-07-01 20:25:32 +02:00
}
#endif
net/tcp and udp: Add logic to signal events when TCP or UDP read-ahead data is buffered. Squashed commit of the following: net/tcp: Add signal notification for the case when UDP read-ahead data is buffered. This is basically of clone of the TCP notification logic with naming adapted for UDP. net/tcp: Add signal notification for the case when TCP read-ahead data is buffered.
2018-09-09 17:21:39 +02:00
Squashed commit of the following: Author: Gregory Nutt <gnutt@nuttx.org> Run all .h and .c files modified in last PR through nxstyle. Author: Xiang Xiao <xiaoxiang@xiaomi.com> Net cleanup (#17) * Fix the semaphore usage issue found in tcp/udp 1. The count semaphore need disable priority inheritance 2. Loop again if net_lockedwait return -EINTR 3. Call nxsem_trywait to avoid the race condition 4. Call nxsem_post instead of sem_post * Put the work notifier into free list to avoid the heap fragment in the long run. Since the allocation strategy is encapsulated internally, we can even refine the implementation later. * Network stack shouldn't allocate memory in the poll implementation to avoid the heap fragment in the long run, other modification include: 1. Select MM_IOB automatically since ICMP[v6] socket can't work without the read ahead buffer 2. Remove the net lock since xxx_callback_free already do the same thing 3. TCP/UDP poll should work even the read ahead buffer isn't enabled at all * Add NET_ prefix for UDP_NOTIFIER and TCP_NOTIFIER option to align with other UDP/TCP option convention * Remove the unused _SF_[IDLE|ACCEPT|SEND|RECV|MASK] flags since there are code to set/clear these flags, but nobody check them.
2019-12-31 16:26:14 +01:00
#endif /* CONFIG_NET_UDP_NOTIFIER */
Reference in New Issue Copy Permalink