sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
4db9513658
nuttx/net/netdev/netdown_notifier.c

143 lines
4.8 KiB
C
Raw Normal View History

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/netdev/netdown_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
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: 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
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: 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.
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
*
****************************************************************************/
/****************************************************************************
* 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>
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
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: 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
#include <nuttx/mm/iob.h>
#include <nuttx/net/netdev.h>
#include "netdev/netdev.h"
#ifdef CONFIG_NETDOWN_NOTIFIER
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: netdown_notifier_setup
*
* Description:
net/netlink: Redesign the logic that handles notifications of when response data is available. Signal handlers are sub-optimal inside the OS (especially after the preceding change which forces the hand). Instead, use the work queue notifiers as is done with all other network notifiers.
2019-11-28 21:20:40 +01:00
* Set up to perform a callback to the worker function when the network
* goes down. The worker function will execute on the high 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
*
* Input Parameters:
sched/wqueue: Add an option to work queue notifier so that the notification can occur on different work queues.
2018-09-11 15:22:23 +02:00
* worker - The worker function to execute on the low priority work
* queue when data is available in the UDP read-ahead buffer.
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
* dev - The network driver to be monitored
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.
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
* Returned Value:
sched/wqueue: Add an option to work queue notifier so that the notification can occur on different work queues.
2018-09-11 15:22:23 +02:00
* > 0 - The notification is in place. The returned value is a key that
* may be used later in a call to netdown_notifier_teardown().
* == 0 - The the device is already down. No notification will be
* provided.
* < 0 - An unexpected error occurred and notification will occur. The
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
* 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 netdown_notifier_setup(worker_t worker, FAR struct net_driver_s *dev,
FAR void *arg)
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
{
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);
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
/* If network driver is already down, then return zero without setting up
* the notification.
*/
if ((dev->d_flags & IFF_UP) == 0)
{
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_NET_DOWN;
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 = dev;
info.arg = arg;
info.worker = worker;
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
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);
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
}
/****************************************************************************
* Name: netdown_notifier_teardown
*
* 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 network down notification previously setup by
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
* netdown_notifier_setup(). This function should only be called if the
* notification should be aborted prior to the notification. The
sched/wqueue: Add an option to work queue notifier so that the notification can occur on different work queues.
2018-09-11 15:22:23 +02:00
* notification will automatically be torn down after the notification.
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
*
* Input Parameters:
* key - The key value returned from a previous call to
* netdown_notifier_setup().
*
* Returned Value:
* Zero (OK) is returned on success; a negated errno value is returned on
* any failure.
*
****************************************************************************/
int netdown_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(). */
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
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);
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
}
/****************************************************************************
* Name: netdown_notifier_signal
*
* 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
* A network has gone down has been buffered. Execute worker thread
* functions for all threads monitoring the state of the device.
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
*
* Input Parameters:
* dev - The TCP connection where read-ahead data was just buffered.
*
* Returned Value:
* None.
*
****************************************************************************/
void netdown_notifier_signal(FAR struct net_driver_s *dev)
{
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(). */
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
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_NET_DOWN, dev);
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
}
#endif /* CONFIG_NETDOWN_NOTIFIER */
Reference in New Issue Copy Permalink