[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
/*
|
2012-11-12 19:36:23 +01:00
|
|
|
* Copyright (C) 2004-2012 Kay Sievers <kay@vrfy.org>
|
[PATCH] convert udevsend/udevd to DGRAM and single-threaded
On Fri, Feb 06, 2004 at 01:08:24AM -0500, Chris Friesen wrote:
>
> Kay, you said "unless we can get rid of _all_ the threads or at least
> getting faster, I don't want to change it."
>
> Well how about we get rid of all the threads, *and* we get faster?
Yes, we are twice as fast now on my box :)
> This patch applies to current bk trees, and does the following:
>
> 1) Switch to DGRAM sockets rather than STREAM. This simplifies things
> as mentioned in the previous message.
>
> 2) Invalid sequence numbers are mapped to -1 rather than zero, since
> zero is a valid sequence number (I think). Also, this allows for real
> speed tests using scripts starting at a zero sequence number, since that
> is what the initial expected sequence number is.
>
> 3) Get rid of all threading. This is the biggie. Some highlights:
> a) timeout using setitimer() and SIGALRM
> b) async child death notification via SIGCHLD
> c) these two signal handlers do nothing but raise volatile flags,
> all the
> work is done in the main loop
> d) locking no longer required
I cleaned up the rest of the comments, the whitespace and a few names to match
the whole thing. Please recheck it. Test script is switched to work on subsystem
'test' to let udev ignore it.
2004-02-07 07:21:15 +01:00
|
|
|
* Copyright (C) 2004 Chris Friesen <chris_friesen@sympatico.ca>
|
2009-03-10 14:00:16 +01:00
|
|
|
* Copyright (C) 2009 Canonical Ltd.
|
|
|
|
* Copyright (C) 2009 Scott James Remnant <scott@netsplit.com>
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
*
|
2008-09-10 02:40:42 +02:00
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
*
|
2008-09-10 02:40:42 +02:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
*
|
2008-09-10 02:40:42 +02:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
*/
|
|
|
|
|
2004-01-27 03:19:33 +01:00
|
|
|
#include <stddef.h>
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
#include <signal.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2009-07-13 03:33:15 +02:00
|
|
|
#include <stdbool.h>
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
#include <string.h>
|
2005-01-17 00:53:08 +01:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <fcntl.h>
|
2005-11-07 02:22:44 +01:00
|
|
|
#include <time.h>
|
2006-09-08 11:27:03 +02:00
|
|
|
#include <getopt.h>
|
2008-11-06 17:43:12 +01:00
|
|
|
#include <dirent.h>
|
2014-04-14 04:54:27 +02:00
|
|
|
#include <sys/file.h>
|
2009-07-17 13:24:37 +02:00
|
|
|
#include <sys/time.h>
|
2009-06-04 01:44:04 +02:00
|
|
|
#include <sys/prctl.h>
|
|
|
|
#include <sys/socket.h>
|
2010-06-17 21:50:58 +02:00
|
|
|
#include <sys/un.h>
|
2009-06-04 01:44:04 +02:00
|
|
|
#include <sys/signalfd.h>
|
2011-04-13 01:17:09 +02:00
|
|
|
#include <sys/epoll.h>
|
2014-06-04 13:30:24 +02:00
|
|
|
#include <sys/mount.h>
|
2009-01-20 12:49:20 +01:00
|
|
|
#include <sys/poll.h>
|
2005-03-10 00:58:01 +01:00
|
|
|
#include <sys/wait.h>
|
2004-10-14 07:37:59 +02:00
|
|
|
#include <sys/stat.h>
|
2005-10-27 21:04:38 +02:00
|
|
|
#include <sys/ioctl.h>
|
2008-07-30 01:45:23 +02:00
|
|
|
#include <sys/inotify.h>
|
2010-05-20 17:09:04 +02:00
|
|
|
#include <sys/utsname.h>
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
|
|
|
|
#include "udev.h"
|
2014-06-04 12:16:28 +02:00
|
|
|
#include "udev-util.h"
|
2014-09-09 11:15:37 +02:00
|
|
|
#include "rtnl-util.h"
|
2010-10-07 14:59:11 +02:00
|
|
|
#include "sd-daemon.h"
|
2012-04-15 02:35:31 +02:00
|
|
|
#include "cgroup-util.h"
|
2012-04-17 22:25:24 +02:00
|
|
|
#include "dev-setup.h"
|
2013-02-14 12:26:13 +01:00
|
|
|
#include "fileio.h"
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
|
2011-12-25 18:59:42 +01:00
|
|
|
void udev_main_log(struct udev *udev, int priority,
|
2012-01-10 01:34:15 +01:00
|
|
|
const char *file, int line, const char *fn,
|
2014-07-29 15:47:41 +02:00
|
|
|
const char *format, va_list args) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_metav(priority, file, line, fn, format, args);
|
2008-09-06 15:45:31 +02:00
|
|
|
}
|
|
|
|
|
2008-10-18 15:02:01 +02:00
|
|
|
static struct udev_rules *rules;
|
2008-09-08 17:59:00 +02:00
|
|
|
static struct udev_ctrl *udev_ctrl;
|
2009-06-04 01:44:04 +02:00
|
|
|
static struct udev_monitor *monitor;
|
2011-03-23 01:45:21 +01:00
|
|
|
static int worker_watch[2] = { -1, -1 };
|
2011-04-13 01:17:09 +02:00
|
|
|
static int fd_signal = -1;
|
|
|
|
static int fd_ep = -1;
|
|
|
|
static int fd_inotify = -1;
|
2009-07-13 03:33:15 +02:00
|
|
|
static bool stop_exec_queue;
|
2011-12-25 16:37:15 +01:00
|
|
|
static bool reload;
|
2010-05-27 17:27:56 +02:00
|
|
|
static int children;
|
2014-09-12 14:42:59 +02:00
|
|
|
static bool arg_debug = false;
|
|
|
|
static int arg_daemonize = false;
|
|
|
|
static int arg_resolve_names = 1;
|
|
|
|
static int arg_children_max;
|
|
|
|
static int arg_exec_delay;
|
|
|
|
static usec_t arg_event_timeout_usec = 180 * USEC_PER_SEC;
|
|
|
|
static usec_t arg_event_timeout_warn_usec = 180 * USEC_PER_SEC / 3;
|
2011-04-20 01:53:03 +02:00
|
|
|
static sigset_t sigmask_orig;
|
2011-04-13 01:17:09 +02:00
|
|
|
static UDEV_LIST(event_list);
|
|
|
|
static UDEV_LIST(worker_list);
|
2013-11-12 18:09:08 +01:00
|
|
|
static char *udev_cgroup;
|
2009-07-13 03:33:15 +02:00
|
|
|
static bool udev_exit;
|
2009-06-04 01:44:04 +02:00
|
|
|
|
|
|
|
enum event_state {
|
2012-01-10 01:34:15 +01:00
|
|
|
EVENT_UNDEF,
|
|
|
|
EVENT_QUEUED,
|
|
|
|
EVENT_RUNNING,
|
2009-06-04 01:44:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct event {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node node;
|
|
|
|
struct udev *udev;
|
|
|
|
struct udev_device *dev;
|
|
|
|
enum event_state state;
|
|
|
|
int exitcode;
|
|
|
|
unsigned long long int delaying_seqnum;
|
|
|
|
unsigned long long int seqnum;
|
|
|
|
const char *devpath;
|
|
|
|
size_t devpath_len;
|
|
|
|
const char *devpath_old;
|
|
|
|
dev_t devnum;
|
|
|
|
int ifindex;
|
2012-10-07 18:21:38 +02:00
|
|
|
bool is_block;
|
2009-06-04 01:44:04 +02:00
|
|
|
};
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static inline struct event *node_to_event(struct udev_list_node *node) {
|
2012-04-26 18:36:02 +02:00
|
|
|
return container_of(node, struct event, node);
|
2009-06-04 01:44:04 +02:00
|
|
|
}
|
|
|
|
|
2011-04-13 01:17:09 +02:00
|
|
|
static void event_queue_cleanup(struct udev *udev, enum event_state type);
|
|
|
|
|
2009-06-04 01:44:04 +02:00
|
|
|
enum worker_state {
|
2012-01-10 01:34:15 +01:00
|
|
|
WORKER_UNDEF,
|
|
|
|
WORKER_RUNNING,
|
|
|
|
WORKER_IDLE,
|
|
|
|
WORKER_KILLED,
|
2009-06-04 01:44:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct worker {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node node;
|
|
|
|
struct udev *udev;
|
|
|
|
int refcount;
|
|
|
|
pid_t pid;
|
|
|
|
struct udev_monitor *monitor;
|
|
|
|
enum worker_state state;
|
|
|
|
struct event *event;
|
2012-11-11 20:45:05 +01:00
|
|
|
usec_t event_start_usec;
|
2014-09-11 18:49:04 +02:00
|
|
|
bool event_warned;
|
2009-06-04 01:44:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* passed from worker to main process */
|
|
|
|
struct worker_message {
|
2012-01-10 01:34:15 +01:00
|
|
|
pid_t pid;
|
|
|
|
int exitcode;
|
2009-06-04 01:44:04 +02:00
|
|
|
};
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static inline struct worker *node_to_worker(struct udev_list_node *node) {
|
2012-04-26 18:36:02 +02:00
|
|
|
return container_of(node, struct worker, node);
|
2008-10-17 18:59:27 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void event_queue_delete(struct event *event) {
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_remove(&event->node);
|
|
|
|
udev_device_unref(event->dev);
|
|
|
|
free(event);
|
2008-10-16 17:16:58 +02:00
|
|
|
}
|
2005-11-16 04:12:53 +01:00
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static struct worker *worker_ref(struct worker *worker) {
|
2012-01-10 01:34:15 +01:00
|
|
|
worker->refcount++;
|
|
|
|
return worker;
|
2009-07-13 03:09:05 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_cleanup(struct worker *worker) {
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_remove(&worker->node);
|
|
|
|
udev_monitor_unref(worker->monitor);
|
|
|
|
children--;
|
|
|
|
free(worker);
|
2011-04-13 01:17:09 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_unref(struct worker *worker) {
|
2012-01-10 01:34:15 +01:00
|
|
|
worker->refcount--;
|
|
|
|
if (worker->refcount > 0)
|
|
|
|
return;
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("worker [%u] cleaned up", worker->pid);
|
2012-01-10 01:34:15 +01:00
|
|
|
worker_cleanup(worker);
|
2011-04-13 01:17:09 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_list_cleanup(struct udev *udev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop, *tmp;
|
2011-04-13 01:17:09 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_foreach_safe(loop, tmp, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
2011-04-13 01:17:09 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
worker_cleanup(worker);
|
|
|
|
}
|
2005-11-07 14:10:09 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_new(struct event *event) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev *udev = event->udev;
|
|
|
|
struct worker *worker;
|
|
|
|
struct udev_monitor *worker_monitor;
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
/* listen for new events */
|
|
|
|
worker_monitor = udev_monitor_new_from_netlink(udev, NULL);
|
|
|
|
if (worker_monitor == NULL)
|
|
|
|
return;
|
|
|
|
/* allow the main daemon netlink address to send devices to the worker */
|
|
|
|
udev_monitor_allow_unicast_sender(worker_monitor, monitor);
|
|
|
|
udev_monitor_enable_receiving(worker_monitor);
|
|
|
|
|
2014-02-13 14:45:51 +01:00
|
|
|
worker = new0(struct worker, 1);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (worker == NULL) {
|
|
|
|
udev_monitor_unref(worker_monitor);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* worker + event reference */
|
|
|
|
worker->refcount = 2;
|
|
|
|
worker->udev = udev;
|
|
|
|
|
|
|
|
pid = fork();
|
|
|
|
switch (pid) {
|
|
|
|
case 0: {
|
|
|
|
struct udev_device *dev = NULL;
|
|
|
|
int fd_monitor;
|
2014-09-09 11:15:37 +02:00
|
|
|
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
2012-01-10 01:34:15 +01:00
|
|
|
struct epoll_event ep_signal, ep_monitor;
|
|
|
|
sigset_t mask;
|
|
|
|
int rc = EXIT_SUCCESS;
|
|
|
|
|
2012-01-21 03:07:32 +01:00
|
|
|
/* take initial device from queue */
|
2012-01-10 01:34:15 +01:00
|
|
|
dev = event->dev;
|
|
|
|
event->dev = NULL;
|
|
|
|
|
|
|
|
free(worker);
|
|
|
|
worker_list_cleanup(udev);
|
|
|
|
event_queue_cleanup(udev, EVENT_UNDEF);
|
|
|
|
udev_monitor_unref(monitor);
|
|
|
|
udev_ctrl_unref(udev_ctrl);
|
|
|
|
close(fd_signal);
|
|
|
|
close(fd_ep);
|
|
|
|
close(worker_watch[READ_END]);
|
|
|
|
|
|
|
|
sigfillset(&mask);
|
|
|
|
fd_signal = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
|
|
|
|
if (fd_signal < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error creating signalfd %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 2;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
fd_ep = epoll_create1(EPOLL_CLOEXEC);
|
|
|
|
if (fd_ep < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error creating epoll fd: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 3;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-01-31 06:51:32 +01:00
|
|
|
memzero(&ep_signal, sizeof(struct epoll_event));
|
2012-01-10 01:34:15 +01:00
|
|
|
ep_signal.events = EPOLLIN;
|
|
|
|
ep_signal.data.fd = fd_signal;
|
|
|
|
|
|
|
|
fd_monitor = udev_monitor_get_fd(worker_monitor);
|
2014-01-31 06:51:32 +01:00
|
|
|
memzero(&ep_monitor, sizeof(struct epoll_event));
|
2012-01-10 01:34:15 +01:00
|
|
|
ep_monitor.events = EPOLLIN;
|
|
|
|
ep_monitor.data.fd = fd_monitor;
|
|
|
|
|
|
|
|
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_signal, &ep_signal) < 0 ||
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_monitor, &ep_monitor) < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("fail to add fds to epoll: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 4;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* request TERM signal if parent exits */
|
|
|
|
prctl(PR_SET_PDEATHSIG, SIGTERM);
|
|
|
|
|
2012-06-04 18:10:50 +02:00
|
|
|
/* reset OOM score, we only protect the main daemon */
|
2013-04-02 20:31:42 +02:00
|
|
|
write_string_file("/proc/self/oom_score_adj", "0");
|
2012-06-04 18:10:50 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
for (;;) {
|
|
|
|
struct udev_event *udev_event;
|
|
|
|
struct worker_message msg;
|
2014-04-14 04:54:27 +02:00
|
|
|
int fd_lock = -1;
|
2014-05-16 23:46:48 +02:00
|
|
|
int err = 0;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("seq %llu running", udev_device_get_seqnum(dev));
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_event = udev_event_new(dev);
|
|
|
|
if (udev_event == NULL) {
|
|
|
|
rc = 5;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* needed for SIGCHLD/SIGTERM in spawn() */
|
|
|
|
udev_event->fd_signal = fd_signal;
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
if (arg_exec_delay > 0)
|
|
|
|
udev_event->exec_delay = arg_exec_delay;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-04-14 04:54:27 +02:00
|
|
|
/*
|
2014-07-24 23:37:35 +02:00
|
|
|
* Take a shared lock on the device node; this establishes
|
2014-04-14 04:54:27 +02:00
|
|
|
* a concept of device "ownership" to serialize device
|
2014-07-24 23:37:35 +02:00
|
|
|
* access. External processes holding an exclusive lock will
|
2014-04-14 04:54:27 +02:00
|
|
|
* cause udev to skip the event handling; in the case udev
|
2014-07-24 23:37:35 +02:00
|
|
|
* acquired the lock, the external process can block until
|
2014-04-14 04:54:27 +02:00
|
|
|
* udev has finished its event handling.
|
|
|
|
*/
|
2014-07-24 23:37:35 +02:00
|
|
|
if (!streq_ptr(udev_device_get_action(dev), "remove") &&
|
|
|
|
streq_ptr("block", udev_device_get_subsystem(dev)) &&
|
|
|
|
!startswith(udev_device_get_sysname(dev), "dm-") &&
|
|
|
|
!startswith(udev_device_get_sysname(dev), "md")) {
|
2014-04-14 04:54:27 +02:00
|
|
|
struct udev_device *d = dev;
|
|
|
|
|
|
|
|
if (streq_ptr("partition", udev_device_get_devtype(d)))
|
|
|
|
d = udev_device_get_parent(d);
|
|
|
|
|
|
|
|
if (d) {
|
|
|
|
fd_lock = open(udev_device_get_devnode(d), O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
|
|
|
|
if (fd_lock >= 0 && flock(fd_lock, LOCK_SH|LOCK_NB) < 0) {
|
|
|
|
log_debug("Unable to flock(%s), skipping event handling: %m", udev_device_get_devnode(d));
|
|
|
|
err = -EWOULDBLOCK;
|
2014-06-03 10:46:51 +02:00
|
|
|
fd_lock = safe_close(fd_lock);
|
2014-04-14 04:54:27 +02:00
|
|
|
goto skip;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-09 11:15:37 +02:00
|
|
|
/* needed for renaming netifs */
|
|
|
|
udev_event->rtnl = rtnl;
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* apply rules, create node, symlinks */
|
2014-09-12 14:42:59 +02:00
|
|
|
udev_event_execute_rules(udev_event, arg_event_timeout_usec, arg_event_timeout_warn_usec, rules, &sigmask_orig);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
udev_event_execute_run(udev_event, arg_event_timeout_usec, arg_event_timeout_warn_usec, &sigmask_orig);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-09 11:15:37 +02:00
|
|
|
/* in case rtnl was initialized */
|
|
|
|
rtnl = sd_rtnl_ref(udev_event->rtnl);
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* apply/restore inotify watch */
|
2014-05-16 23:46:48 +02:00
|
|
|
if (udev_event->inotify_watch) {
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_watch_begin(udev, dev);
|
|
|
|
udev_device_update_db(dev);
|
|
|
|
}
|
|
|
|
|
2014-06-03 10:46:51 +02:00
|
|
|
safe_close(fd_lock);
|
2014-04-14 04:54:27 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* send processed event back to libudev listeners */
|
|
|
|
udev_monitor_send_device(worker_monitor, NULL, dev);
|
|
|
|
|
2014-04-14 04:54:27 +02:00
|
|
|
skip:
|
2012-01-10 01:34:15 +01:00
|
|
|
/* send udevd the result of the event execution */
|
2014-01-31 06:51:32 +01:00
|
|
|
memzero(&msg, sizeof(struct worker_message));
|
2014-04-14 04:54:27 +02:00
|
|
|
msg.exitcode = err;
|
2012-01-10 01:34:15 +01:00
|
|
|
msg.pid = getpid();
|
|
|
|
send(worker_watch[WRITE_END], &msg, sizeof(struct worker_message), 0);
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("seq %llu processed with %i", udev_device_get_seqnum(dev), err);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
udev_device_unref(dev);
|
|
|
|
dev = NULL;
|
|
|
|
|
2013-08-22 23:03:29 +02:00
|
|
|
if (udev_event->sigterm) {
|
|
|
|
udev_event_unref(udev_event);
|
2013-08-15 19:51:08 +02:00
|
|
|
goto out;
|
2013-08-22 23:03:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
udev_event_unref(udev_event);
|
2013-08-15 19:51:08 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* wait for more device messages from main udevd, or term signal */
|
|
|
|
while (dev == NULL) {
|
|
|
|
struct epoll_event ev[4];
|
|
|
|
int fdcount;
|
|
|
|
int i;
|
|
|
|
|
2012-04-16 03:13:22 +02:00
|
|
|
fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (fdcount < 0) {
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("failed to poll: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < fdcount; i++) {
|
|
|
|
if (ev[i].data.fd == fd_monitor && ev[i].events & EPOLLIN) {
|
|
|
|
dev = udev_monitor_receive_device(worker_monitor);
|
|
|
|
break;
|
|
|
|
} else if (ev[i].data.fd == fd_signal && ev[i].events & EPOLLIN) {
|
|
|
|
struct signalfd_siginfo fdsi;
|
|
|
|
ssize_t size;
|
|
|
|
|
|
|
|
size = read(fd_signal, &fdsi, sizeof(struct signalfd_siginfo));
|
|
|
|
if (size != sizeof(struct signalfd_siginfo))
|
|
|
|
continue;
|
|
|
|
switch (fdsi.ssi_signo) {
|
|
|
|
case SIGTERM:
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-04-18 02:14:24 +02:00
|
|
|
out:
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_device_unref(dev);
|
2014-06-03 10:46:51 +02:00
|
|
|
safe_close(fd_signal);
|
|
|
|
safe_close(fd_ep);
|
2012-01-10 01:34:15 +01:00
|
|
|
close(fd_inotify);
|
|
|
|
close(worker_watch[WRITE_END]);
|
|
|
|
udev_rules_unref(rules);
|
2012-01-18 05:06:18 +01:00
|
|
|
udev_builtin_exit(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_monitor_unref(worker_monitor);
|
|
|
|
udev_unref(udev);
|
2012-04-08 16:06:20 +02:00
|
|
|
log_close();
|
2012-01-10 01:34:15 +01:00
|
|
|
exit(rc);
|
|
|
|
}
|
|
|
|
case -1:
|
|
|
|
udev_monitor_unref(worker_monitor);
|
|
|
|
event->state = EVENT_QUEUED;
|
|
|
|
free(worker);
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("fork of child failed: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* close monitor, but keep address around */
|
|
|
|
udev_monitor_disconnect(worker_monitor);
|
|
|
|
worker->monitor = worker_monitor;
|
|
|
|
worker->pid = pid;
|
|
|
|
worker->state = WORKER_RUNNING;
|
2012-11-11 20:45:05 +01:00
|
|
|
worker->event_start_usec = now(CLOCK_MONOTONIC);
|
2014-09-11 18:49:04 +02:00
|
|
|
worker->event_warned = false;
|
2012-01-10 01:34:15 +01:00
|
|
|
worker->event = event;
|
|
|
|
event->state = EVENT_RUNNING;
|
|
|
|
udev_list_node_append(&worker->node, &worker_list);
|
|
|
|
children++;
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("seq %llu forked new worker [%u]", udev_device_get_seqnum(event->dev), pid);
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
}
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void event_run(struct event *event) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop;
|
|
|
|
|
|
|
|
udev_list_node_foreach(loop, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
|
|
|
ssize_t count;
|
|
|
|
|
|
|
|
if (worker->state != WORKER_IDLE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
count = udev_monitor_send_device(monitor, worker->monitor, event->dev);
|
|
|
|
if (count < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] did not accept message %zi (%m), kill it", worker->pid, count);
|
2012-01-10 01:34:15 +01:00
|
|
|
kill(worker->pid, SIGKILL);
|
|
|
|
worker->state = WORKER_KILLED;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
worker_ref(worker);
|
|
|
|
worker->event = event;
|
|
|
|
worker->state = WORKER_RUNNING;
|
2012-11-11 20:45:05 +01:00
|
|
|
worker->event_start_usec = now(CLOCK_MONOTONIC);
|
2014-09-11 18:49:04 +02:00
|
|
|
worker->event_warned = false;
|
2012-01-10 01:34:15 +01:00
|
|
|
event->state = EVENT_RUNNING;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
if (children >= arg_children_max) {
|
|
|
|
if (arg_children_max > 1)
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("maximum number (%i) of children reached", children);
|
2012-01-10 01:34:15 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* start new worker and pass initial device */
|
|
|
|
worker_new(event);
|
2009-06-04 01:44:04 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static int event_queue_insert(struct udev_device *dev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct event *event;
|
|
|
|
|
2014-02-13 14:45:51 +01:00
|
|
|
event = new0(struct event, 1);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (event == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
event->udev = udev_device_get_udev(dev);
|
|
|
|
event->dev = dev;
|
|
|
|
event->seqnum = udev_device_get_seqnum(dev);
|
|
|
|
event->devpath = udev_device_get_devpath(dev);
|
|
|
|
event->devpath_len = strlen(event->devpath);
|
|
|
|
event->devpath_old = udev_device_get_devpath_old(dev);
|
|
|
|
event->devnum = udev_device_get_devnum(dev);
|
2012-10-07 18:21:38 +02:00
|
|
|
event->is_block = streq("block", udev_device_get_subsystem(dev));
|
2012-01-10 01:34:15 +01:00
|
|
|
event->ifindex = udev_device_get_ifindex(dev);
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("seq %llu queued, '%s' '%s'", udev_device_get_seqnum(dev),
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_device_get_action(dev), udev_device_get_subsystem(dev));
|
|
|
|
|
|
|
|
event->state = EVENT_QUEUED;
|
|
|
|
udev_list_node_append(&event->node, &event_list);
|
|
|
|
return 0;
|
2005-11-07 14:10:09 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_kill(struct udev *udev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop;
|
2009-06-04 01:44:04 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_foreach(loop, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
2009-06-04 01:44:04 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
if (worker->state == WORKER_KILLED)
|
|
|
|
continue;
|
2009-06-04 01:44:04 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
worker->state = WORKER_KILLED;
|
|
|
|
kill(worker->pid, SIGTERM);
|
|
|
|
}
|
2009-06-04 01:44:04 +02:00
|
|
|
}
|
|
|
|
|
2009-05-04 22:08:05 +02:00
|
|
|
/* lookup event for identical, parent, child device */
|
2014-07-29 15:47:41 +02:00
|
|
|
static bool is_devpath_busy(struct event *event) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop;
|
|
|
|
size_t common;
|
|
|
|
|
|
|
|
/* check if queue contains events we depend on */
|
|
|
|
udev_list_node_foreach(loop, &event_list) {
|
|
|
|
struct event *loop_event = node_to_event(loop);
|
|
|
|
|
|
|
|
/* we already found a later event, earlier can not block us, no need to check again */
|
|
|
|
if (loop_event->seqnum < event->delaying_seqnum)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* event we checked earlier still exists, no need to check again */
|
|
|
|
if (loop_event->seqnum == event->delaying_seqnum)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* found ourself, no later event can block us */
|
|
|
|
if (loop_event->seqnum >= event->seqnum)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* check major/minor */
|
|
|
|
if (major(event->devnum) != 0 && event->devnum == loop_event->devnum && event->is_block == loop_event->is_block)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* check network device ifindex */
|
|
|
|
if (event->ifindex != 0 && event->ifindex == loop_event->ifindex)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* check our old name */
|
2013-02-13 18:13:22 +01:00
|
|
|
if (event->devpath_old != NULL && streq(loop_event->devpath, event->devpath_old)) {
|
2012-01-10 01:34:15 +01:00
|
|
|
event->delaying_seqnum = loop_event->seqnum;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* compare devpath */
|
|
|
|
common = MIN(loop_event->devpath_len, event->devpath_len);
|
|
|
|
|
|
|
|
/* one devpath is contained in the other? */
|
|
|
|
if (memcmp(loop_event->devpath, event->devpath, common) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* identical device event found */
|
|
|
|
if (loop_event->devpath_len == event->devpath_len) {
|
|
|
|
/* devices names might have changed/swapped in the meantime */
|
|
|
|
if (major(event->devnum) != 0 && (event->devnum != loop_event->devnum || event->is_block != loop_event->is_block))
|
|
|
|
continue;
|
|
|
|
if (event->ifindex != 0 && event->ifindex != loop_event->ifindex)
|
|
|
|
continue;
|
|
|
|
event->delaying_seqnum = loop_event->seqnum;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* parent device event found */
|
|
|
|
if (event->devpath[common] == '/') {
|
|
|
|
event->delaying_seqnum = loop_event->seqnum;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* child device event found */
|
|
|
|
if (loop_event->devpath[common] == '/') {
|
|
|
|
event->delaying_seqnum = loop_event->seqnum;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* no matching device */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void event_queue_start(struct udev *udev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop;
|
2005-06-16 01:58:47 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_foreach(loop, &event_list) {
|
|
|
|
struct event *event = node_to_event(loop);
|
2008-10-29 17:32:13 +01:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
if (event->state != EVENT_QUEUED)
|
|
|
|
continue;
|
2008-10-29 17:32:13 +01:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* do not start event if parent or child event is still running */
|
2012-04-08 16:06:20 +02:00
|
|
|
if (is_devpath_busy(event))
|
2012-01-10 01:34:15 +01:00
|
|
|
continue;
|
2005-11-07 14:10:09 +01:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
event_run(event);
|
|
|
|
}
|
2009-06-04 01:44:04 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void event_queue_cleanup(struct udev *udev, enum event_state match_type) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_node *loop, *tmp;
|
2011-04-13 01:17:09 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_list_node_foreach_safe(loop, tmp, &event_list) {
|
|
|
|
struct event *event = node_to_event(loop);
|
2011-04-13 01:17:09 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
if (match_type != EVENT_UNDEF && match_type != event->state)
|
|
|
|
continue;
|
2011-04-13 01:17:09 +02:00
|
|
|
|
2014-04-13 07:35:50 +02:00
|
|
|
event_queue_delete(event);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
2011-04-13 01:17:09 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void worker_returned(int fd_worker) {
|
2012-01-10 01:34:15 +01:00
|
|
|
for (;;) {
|
|
|
|
struct worker_message msg;
|
|
|
|
ssize_t size;
|
|
|
|
struct udev_list_node *loop;
|
|
|
|
|
|
|
|
size = recv(fd_worker, &msg, sizeof(struct worker_message), MSG_DONTWAIT);
|
|
|
|
if (size != sizeof(struct worker_message))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* lookup worker who sent the signal */
|
|
|
|
udev_list_node_foreach(loop, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
|
|
|
|
|
|
|
if (worker->pid != msg.pid)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* worker returned */
|
2012-01-18 05:06:18 +01:00
|
|
|
if (worker->event) {
|
|
|
|
worker->event->exitcode = msg.exitcode;
|
2014-04-13 07:35:50 +02:00
|
|
|
event_queue_delete(worker->event);
|
2012-01-18 05:06:18 +01:00
|
|
|
worker->event = NULL;
|
|
|
|
}
|
2012-01-10 01:34:15 +01:00
|
|
|
if (worker->state != WORKER_KILLED)
|
|
|
|
worker->state = WORKER_IDLE;
|
|
|
|
worker_unref(worker);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-06-05 04:38:10 +02:00
|
|
|
}
|
|
|
|
|
2005-06-05 04:41:09 +02:00
|
|
|
/* receive the udevd message from userspace */
|
2014-07-29 15:47:41 +02:00
|
|
|
static struct udev_ctrl_connection *handle_ctrl_msg(struct udev_ctrl *uctrl) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev *udev = udev_ctrl_get_udev(uctrl);
|
|
|
|
struct udev_ctrl_connection *ctrl_conn;
|
|
|
|
struct udev_ctrl_msg *ctrl_msg = NULL;
|
|
|
|
const char *str;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ctrl_conn = udev_ctrl_get_connection(uctrl);
|
|
|
|
if (ctrl_conn == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ctrl_msg = udev_ctrl_receive_msg(ctrl_conn);
|
|
|
|
if (ctrl_msg == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
i = udev_ctrl_get_set_log_level(ctrl_msg);
|
|
|
|
if (i >= 0) {
|
2013-12-29 18:05:25 +01:00
|
|
|
log_debug("udevd message (SET_LOG_LEVEL) received, log_priority=%i", i);
|
2012-04-08 16:06:20 +02:00
|
|
|
log_set_max_level(i);
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_set_log_priority(udev, i);
|
2012-04-15 02:35:31 +02:00
|
|
|
worker_kill(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (STOP_EXEC_QUEUE) received");
|
2012-01-10 01:34:15 +01:00
|
|
|
stop_exec_queue = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (START_EXEC_QUEUE) received");
|
2012-01-10 01:34:15 +01:00
|
|
|
stop_exec_queue = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_ctrl_get_reload(ctrl_msg) > 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (RELOAD) received");
|
2012-01-10 01:34:15 +01:00
|
|
|
reload = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
str = udev_ctrl_get_set_env(ctrl_msg);
|
|
|
|
if (str != NULL) {
|
|
|
|
char *key;
|
|
|
|
|
|
|
|
key = strdup(str);
|
|
|
|
if (key != NULL) {
|
|
|
|
char *val;
|
|
|
|
|
|
|
|
val = strchr(key, '=');
|
|
|
|
if (val != NULL) {
|
|
|
|
val[0] = '\0';
|
|
|
|
val = &val[1];
|
|
|
|
if (val[0] == '\0') {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (ENV) received, unset '%s'", key);
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_add_property(udev, key, NULL);
|
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (ENV) received, set '%s=%s'", key, val);
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_add_property(udev, key, val);
|
|
|
|
}
|
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("wrong key format '%s'", key);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
free(key);
|
|
|
|
}
|
2012-04-15 02:35:31 +02:00
|
|
|
worker_kill(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
i = udev_ctrl_get_set_children_max(ctrl_msg);
|
|
|
|
if (i >= 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (SET_MAX_CHILDREN) received, children_max=%i", i);
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_children_max = i;
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_ctrl_get_ping(ctrl_msg) > 0)
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (SYNC) received");
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
if (udev_ctrl_get_exit(ctrl_msg) > 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("udevd message (EXIT) received");
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_exit = true;
|
|
|
|
/* keep reference to block the client until we exit */
|
|
|
|
udev_ctrl_connection_ref(ctrl_conn);
|
|
|
|
}
|
2011-04-13 01:17:09 +02:00
|
|
|
out:
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_ctrl_msg_unref(ctrl_msg);
|
|
|
|
return udev_ctrl_connection_unref(ctrl_conn);
|
2005-06-05 04:38:10 +02:00
|
|
|
}
|
2004-11-06 14:30:15 +01:00
|
|
|
|
2014-06-04 12:16:28 +02:00
|
|
|
static int synthesize_change(struct udev_device *dev) {
|
2014-06-04 11:05:45 +02:00
|
|
|
char filename[UTIL_PATH_SIZE];
|
2014-06-04 12:16:28 +02:00
|
|
|
int r;
|
2014-06-04 11:05:45 +02:00
|
|
|
|
2014-06-04 12:16:28 +02:00
|
|
|
if (streq_ptr("block", udev_device_get_subsystem(dev)) &&
|
2014-06-04 13:30:24 +02:00
|
|
|
streq_ptr("disk", udev_device_get_devtype(dev)) &&
|
2014-06-10 15:51:15 +02:00
|
|
|
!startswith(udev_device_get_sysname(dev), "dm-")) {
|
2014-06-04 15:17:15 +02:00
|
|
|
bool part_table_read = false;
|
|
|
|
bool has_partitions = false;
|
2014-06-04 13:30:24 +02:00
|
|
|
int fd;
|
2014-06-04 12:16:28 +02:00
|
|
|
struct udev *udev = udev_device_get_udev(dev);
|
|
|
|
_cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
|
|
|
|
struct udev_list_entry *item;
|
|
|
|
|
2014-06-04 13:30:24 +02:00
|
|
|
/*
|
2014-06-04 15:17:15 +02:00
|
|
|
* Try to re-read the partition table. This only succeeds if
|
|
|
|
* none of the devices is busy. The kernel returns 0 if no
|
|
|
|
* partition table is found, and we will not get an event for
|
|
|
|
* the disk.
|
2014-06-04 13:30:24 +02:00
|
|
|
*/
|
2014-06-04 16:21:19 +02:00
|
|
|
fd = open(udev_device_get_devnode(dev), O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
|
2014-06-04 13:30:24 +02:00
|
|
|
if (fd >= 0) {
|
2014-06-04 16:21:19 +02:00
|
|
|
r = flock(fd, LOCK_EX|LOCK_NB);
|
|
|
|
if (r >= 0)
|
|
|
|
r = ioctl(fd, BLKRRPART, 0);
|
|
|
|
|
2014-06-04 13:30:24 +02:00
|
|
|
close(fd);
|
|
|
|
if (r >= 0)
|
2014-06-04 15:17:15 +02:00
|
|
|
part_table_read = true;
|
2014-06-04 13:30:24 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 15:17:15 +02:00
|
|
|
/* search for partitions */
|
2014-06-04 12:16:28 +02:00
|
|
|
e = udev_enumerate_new(udev);
|
|
|
|
if (!e)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
r = udev_enumerate_add_match_parent(e, dev);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = udev_enumerate_add_match_subsystem(e, "block");
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = udev_enumerate_scan_devices(e);
|
2014-06-04 23:40:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-06-04 15:17:15 +02:00
|
|
|
|
|
|
|
udev_list_entry_foreach(item, udev_enumerate_get_list_entry(e)) {
|
|
|
|
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
|
|
|
|
|
|
|
|
d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
|
|
|
|
if (!d)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!streq_ptr("partition", udev_device_get_devtype(d)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
has_partitions = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have partitions and re-read the table, the kernel already sent
|
|
|
|
* out a "change" event for the disk, and "remove/add" for all
|
|
|
|
* partitions.
|
|
|
|
*/
|
|
|
|
if (part_table_read && has_partitions)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have partitions but re-reading the partition table did not
|
|
|
|
* work, synthesize "change" for the disk and all partitions.
|
|
|
|
*/
|
|
|
|
log_debug("device %s closed, synthesising 'change'", udev_device_get_devnode(dev));
|
|
|
|
strscpyl(filename, sizeof(filename), udev_device_get_syspath(dev), "/uevent", NULL);
|
|
|
|
write_string_file(filename, "change");
|
|
|
|
|
2014-06-04 12:16:28 +02:00
|
|
|
udev_list_entry_foreach(item, udev_enumerate_get_list_entry(e)) {
|
|
|
|
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
|
|
|
|
|
|
|
|
d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
|
|
|
|
if (!d)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!streq_ptr("partition", udev_device_get_devtype(d)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
log_debug("device %s closed, synthesising partition '%s' 'change'",
|
|
|
|
udev_device_get_devnode(dev), udev_device_get_devnode(d));
|
|
|
|
strscpyl(filename, sizeof(filename), udev_device_get_syspath(d), "/uevent", NULL);
|
|
|
|
write_string_file(filename, "change");
|
|
|
|
}
|
2014-06-04 13:30:24 +02:00
|
|
|
|
|
|
|
return 0;
|
2014-06-04 12:16:28 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 13:30:24 +02:00
|
|
|
log_debug("device %s closed, synthesising 'change'", udev_device_get_devnode(dev));
|
|
|
|
strscpyl(filename, sizeof(filename), udev_device_get_syspath(dev), "/uevent", NULL);
|
|
|
|
write_string_file(filename, "change");
|
|
|
|
|
2014-06-04 12:16:28 +02:00
|
|
|
return 0;
|
2014-06-04 11:05:45 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static int handle_inotify(struct udev *udev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
int nbytes, pos;
|
|
|
|
char *buf;
|
|
|
|
struct inotify_event *ev;
|
2014-06-04 11:05:45 +02:00
|
|
|
int r;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-06-04 11:05:45 +02:00
|
|
|
r = ioctl(fd_inotify, FIONREAD, &nbytes);
|
|
|
|
if (r < 0 || nbytes <= 0)
|
|
|
|
return -errno;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
buf = malloc(nbytes);
|
2014-06-04 11:05:45 +02:00
|
|
|
if (!buf) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error getting buffer for inotify");
|
2014-06-04 11:05:45 +02:00
|
|
|
return -ENOMEM;
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
nbytes = read(fd_inotify, buf, nbytes);
|
|
|
|
|
|
|
|
for (pos = 0; pos < nbytes; pos += sizeof(struct inotify_event) + ev->len) {
|
|
|
|
struct udev_device *dev;
|
|
|
|
|
|
|
|
ev = (struct inotify_event *)(buf + pos);
|
|
|
|
dev = udev_watch_lookup(udev, ev->wd);
|
2014-06-04 11:05:45 +02:00
|
|
|
if (!dev)
|
|
|
|
continue;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-06-04 11:05:45 +02:00
|
|
|
log_debug("inotify event: %x for %s", ev->mask, udev_device_get_devnode(dev));
|
|
|
|
if (ev->mask & IN_CLOSE_WRITE)
|
|
|
|
synthesize_change(dev);
|
|
|
|
else if (ev->mask & IN_IGNORED)
|
|
|
|
udev_watch_end(udev, dev);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-06-04 11:05:45 +02:00
|
|
|
udev_device_unref(dev);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
free(buf);
|
|
|
|
return 0;
|
2009-02-11 18:38:56 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static void handle_signal(struct udev *udev, int signo) {
|
2012-01-10 01:34:15 +01:00
|
|
|
switch (signo) {
|
|
|
|
case SIGINT:
|
|
|
|
case SIGTERM:
|
|
|
|
udev_exit = true;
|
|
|
|
break;
|
|
|
|
case SIGCHLD:
|
|
|
|
for (;;) {
|
|
|
|
pid_t pid;
|
|
|
|
int status;
|
|
|
|
struct udev_list_node *loop, *tmp;
|
|
|
|
|
|
|
|
pid = waitpid(-1, &status, WNOHANG);
|
|
|
|
if (pid <= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
udev_list_node_foreach_safe(loop, tmp, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
|
|
|
|
|
|
|
if (worker->pid != pid)
|
|
|
|
continue;
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("worker [%u] exit", pid);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
if (WIFEXITED(status)) {
|
|
|
|
if (WEXITSTATUS(status) != 0)
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] exit with return code %i",
|
2013-10-12 01:34:21 +02:00
|
|
|
pid, WEXITSTATUS(status));
|
2012-01-10 01:34:15 +01:00
|
|
|
} else if (WIFSIGNALED(status)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] terminated by signal %i (%s)",
|
2013-10-12 01:34:21 +02:00
|
|
|
pid, WTERMSIG(status), strsignal(WTERMSIG(status)));
|
2012-01-10 01:34:15 +01:00
|
|
|
} else if (WIFSTOPPED(status)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] stopped", pid);
|
2012-01-10 01:34:15 +01:00
|
|
|
} else if (WIFCONTINUED(status)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] continued", pid);
|
2012-01-10 01:34:15 +01:00
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] exit with status 0x%04x", pid, status);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
|
2012-01-18 05:06:18 +01:00
|
|
|
if (worker->event) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("worker [%u] failed while handling '%s'",
|
2012-04-08 16:06:20 +02:00
|
|
|
pid, worker->event->devpath);
|
2012-01-10 01:34:15 +01:00
|
|
|
worker->event->exitcode = -32;
|
2014-04-13 07:35:50 +02:00
|
|
|
event_queue_delete(worker->event);
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* drop reference taken for state 'running' */
|
|
|
|
worker_unref(worker);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
worker_unref(worker);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SIGHUP:
|
|
|
|
reload = true;
|
|
|
|
break;
|
|
|
|
}
|
2004-04-01 09:03:07 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static int systemd_fds(struct udev *udev, int *rctrl, int *rnetlink) {
|
2012-01-10 01:34:15 +01:00
|
|
|
int ctrl = -1, netlink = -1;
|
|
|
|
int fd, n;
|
|
|
|
|
|
|
|
n = sd_listen_fds(true);
|
|
|
|
if (n <= 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (fd = SD_LISTEN_FDS_START; fd < n + SD_LISTEN_FDS_START; fd++) {
|
|
|
|
if (sd_is_socket(fd, AF_LOCAL, SOCK_SEQPACKET, -1)) {
|
|
|
|
if (ctrl >= 0)
|
|
|
|
return -1;
|
|
|
|
ctrl = fd;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1)) {
|
|
|
|
if (netlink >= 0)
|
|
|
|
return -1;
|
|
|
|
netlink = fd;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctrl < 0 || netlink < 0)
|
|
|
|
return -1;
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("ctrl=%i netlink=%i", ctrl, netlink);
|
2012-01-10 01:34:15 +01:00
|
|
|
*rctrl = ctrl;
|
|
|
|
*rnetlink = netlink;
|
|
|
|
return 0;
|
2011-04-14 23:46:44 +02:00
|
|
|
}
|
|
|
|
|
2012-06-04 22:46:32 +02:00
|
|
|
/*
|
|
|
|
* read the kernel commandline, in case we need to get into debug mode
|
|
|
|
* udev.log-priority=<level> syslog priority
|
|
|
|
* udev.children-max=<number of workers> events are fully serialized if set to 1
|
|
|
|
* udev.exec-delay=<number of seconds> delay execution of every executed program
|
|
|
|
*/
|
2014-07-29 15:47:41 +02:00
|
|
|
static void kernel_cmdline_options(struct udev *udev) {
|
2013-11-06 03:15:16 +01:00
|
|
|
_cleanup_free_ char *line = NULL;
|
2014-07-30 04:01:36 +02:00
|
|
|
const char *word, *state;
|
2012-06-04 22:46:32 +02:00
|
|
|
size_t l;
|
2013-11-06 03:15:16 +01:00
|
|
|
int r;
|
2012-06-04 22:46:32 +02:00
|
|
|
|
2013-11-06 03:15:16 +01:00
|
|
|
r = proc_cmdline(&line);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
|
|
|
|
if (r <= 0)
|
2012-06-04 22:46:32 +02:00
|
|
|
return;
|
|
|
|
|
2014-07-30 04:01:36 +02:00
|
|
|
FOREACH_WORD_QUOTED(word, l, line, state) {
|
2012-06-04 22:46:32 +02:00
|
|
|
char *s, *opt;
|
|
|
|
|
2014-07-30 04:01:36 +02:00
|
|
|
s = strndup(word, l);
|
2012-06-04 22:46:32 +02:00
|
|
|
if (!s)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* accept the same options for the initrd, prefixed with "rd." */
|
|
|
|
if (in_initrd() && startswith(s, "rd."))
|
|
|
|
opt = s + 3;
|
|
|
|
else
|
|
|
|
opt = s;
|
|
|
|
|
2012-07-30 22:34:07 +02:00
|
|
|
if (startswith(opt, "udev.log-priority=")) {
|
|
|
|
int prio;
|
2012-06-04 22:46:32 +02:00
|
|
|
|
2012-07-30 22:34:07 +02:00
|
|
|
prio = util_log_priority(opt + 18);
|
|
|
|
log_set_max_level(prio);
|
|
|
|
udev_set_log_priority(udev, prio);
|
|
|
|
} else if (startswith(opt, "udev.children-max=")) {
|
2014-09-15 14:41:30 +02:00
|
|
|
r = safe_atoi(opt + 18, &arg_children_max);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning("Invalid udev.children-max ignored: %s", opt + 18);
|
2012-07-30 22:34:07 +02:00
|
|
|
} else if (startswith(opt, "udev.exec-delay=")) {
|
2014-09-15 14:41:30 +02:00
|
|
|
r = safe_atoi(opt + 16, &arg_exec_delay);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning("Invalid udev.exec-delay ignored: %s", opt + 16);
|
2014-07-29 09:06:14 +02:00
|
|
|
} else if (startswith(opt, "udev.event-timeout=")) {
|
2014-09-15 14:41:30 +02:00
|
|
|
r = safe_atou64(opt + 16, &arg_event_timeout_usec);
|
|
|
|
if (r < 0) {
|
|
|
|
log_warning("Invalid udev.event-timeout ignored: %s", opt + 16);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
arg_event_timeout_usec *= USEC_PER_SEC;
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_event_timeout_warn_usec = (arg_event_timeout_usec / 3) ? : 1;
|
2012-07-30 22:34:07 +02:00
|
|
|
}
|
2012-06-04 22:46:32 +02:00
|
|
|
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-12 14:18:06 +02:00
|
|
|
static void help(void) {
|
|
|
|
printf("%s [OPTIONS...]\n\n"
|
|
|
|
"Manages devices.\n\n"
|
|
|
|
" --daemon\n"
|
|
|
|
" --debug\n"
|
|
|
|
" --children-max=<maximum number of workers>\n"
|
|
|
|
" --exec-delay=<seconds to wait before executing RUN=>\n"
|
|
|
|
" --event-timeout=<seconds to wait before terminating an event>\n"
|
|
|
|
" --resolve-names=early|late|never\n"
|
|
|
|
" --version\n"
|
|
|
|
" --help\n"
|
|
|
|
, program_invocation_short_name);
|
|
|
|
}
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
static int parse_argv(int argc, char *argv[]) {
|
2012-01-10 01:34:15 +01:00
|
|
|
static const struct option options[] = {
|
2014-09-12 14:42:59 +02:00
|
|
|
{ "daemon", no_argument, NULL, 'd' },
|
|
|
|
{ "debug", no_argument, NULL, 'D' },
|
|
|
|
{ "children-max", required_argument, NULL, 'c' },
|
|
|
|
{ "exec-delay", required_argument, NULL, 'e' },
|
|
|
|
{ "event-timeout", required_argument, NULL, 't' },
|
|
|
|
{ "resolve-names", required_argument, NULL, 'N' },
|
|
|
|
{ "help", no_argument, NULL, 'h' },
|
|
|
|
{ "version", no_argument, NULL, 'V' },
|
2012-01-10 01:34:15 +01:00
|
|
|
{}
|
|
|
|
};
|
2013-08-08 21:44:02 +02:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
int c;
|
2013-08-08 21:44:02 +02:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
assert(argc >= 0);
|
|
|
|
assert(argv);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
while ((c = getopt_long(argc, argv, "c:de:DtN:hV", options, NULL)) >= 0) {
|
2014-09-15 14:41:30 +02:00
|
|
|
int r;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
switch (c) {
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
case 'd':
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_daemonize = true;
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
case 'c':
|
2014-09-18 19:02:03 +02:00
|
|
|
r = safe_atoi(optarg, &arg_children_max);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning("Invalid --children-max ignored: %s", optarg);
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
case 'e':
|
2014-09-18 19:02:03 +02:00
|
|
|
r = safe_atoi(optarg, &arg_exec_delay);
|
|
|
|
if (r < 0)
|
|
|
|
log_warning("Invalid --exec-delay ignored: %s", optarg);
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
2014-07-29 09:06:14 +02:00
|
|
|
case 't':
|
2014-09-15 14:41:30 +02:00
|
|
|
r = safe_atou64(optarg, &arg_event_timeout_usec);
|
|
|
|
if (r < 0)
|
2014-09-18 20:25:33 +02:00
|
|
|
log_warning("Invalid --event-timeout ignored: %s", optarg);
|
2014-09-18 19:02:03 +02:00
|
|
|
else {
|
|
|
|
arg_event_timeout_usec *= USEC_PER_SEC;
|
|
|
|
arg_event_timeout_warn_usec = (arg_event_timeout_usec / 3) ? : 1;
|
|
|
|
}
|
2014-07-29 09:06:14 +02:00
|
|
|
break;
|
2012-01-10 01:34:15 +01:00
|
|
|
case 'D':
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_debug = true;
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
case 'N':
|
2013-02-13 18:13:22 +01:00
|
|
|
if (streq(optarg, "early")) {
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_resolve_names = 1;
|
2013-02-13 18:13:22 +01:00
|
|
|
} else if (streq(optarg, "late")) {
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_resolve_names = 0;
|
2013-02-13 18:13:22 +01:00
|
|
|
} else if (streq(optarg, "never")) {
|
2014-09-12 14:42:59 +02:00
|
|
|
arg_resolve_names = -1;
|
2012-01-10 01:34:15 +01:00
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("resolve-names must be early, late or never");
|
2014-09-12 14:42:59 +02:00
|
|
|
return 0;
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'h':
|
2014-09-12 14:18:06 +02:00
|
|
|
help();
|
2014-09-12 14:42:59 +02:00
|
|
|
return 0;
|
2012-01-10 01:34:15 +01:00
|
|
|
case 'V':
|
|
|
|
printf("%s\n", VERSION);
|
2014-09-12 14:42:59 +02:00
|
|
|
return 0;
|
|
|
|
case '?':
|
|
|
|
return -EINVAL;
|
2012-01-10 01:34:15 +01:00
|
|
|
default:
|
2014-09-12 14:42:59 +02:00
|
|
|
assert_not_reached("Unhandled option");
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]) {
|
|
|
|
struct udev *udev;
|
|
|
|
sigset_t mask;
|
|
|
|
int fd_ctrl = -1;
|
|
|
|
int fd_netlink = -1;
|
|
|
|
int fd_worker = -1;
|
2014-09-12 16:45:19 +02:00
|
|
|
struct epoll_event ep_ctrl = { .events = EPOLLIN };
|
|
|
|
struct epoll_event ep_inotify = { .events = EPOLLIN };
|
|
|
|
struct epoll_event ep_signal = { .events = EPOLLIN };
|
|
|
|
struct epoll_event ep_netlink = { .events = EPOLLIN };
|
|
|
|
struct epoll_event ep_worker = { .events = EPOLLIN };
|
2014-09-12 14:42:59 +02:00
|
|
|
struct udev_ctrl_connection *ctrl_conn = NULL;
|
|
|
|
int rc = 1, r;
|
|
|
|
|
|
|
|
udev = udev_new();
|
|
|
|
if (udev == NULL)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
log_set_target(LOG_TARGET_AUTO);
|
|
|
|
log_parse_environment();
|
|
|
|
log_open();
|
|
|
|
|
|
|
|
udev_set_log_fn(udev, udev_main_log);
|
|
|
|
log_set_max_level(udev_get_log_priority(udev));
|
|
|
|
|
|
|
|
r = parse_argv(argc, argv);
|
|
|
|
if (r <= 0)
|
|
|
|
goto exit;
|
|
|
|
|
2012-06-04 22:46:32 +02:00
|
|
|
kernel_cmdline_options(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
if (arg_debug) {
|
|
|
|
log_set_max_level(LOG_DEBUG);
|
|
|
|
udev_set_log_priority(udev, LOG_DEBUG);
|
|
|
|
}
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
if (getuid() != 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("root privileges required");
|
2012-01-10 01:34:15 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2014-09-18 19:07:02 +02:00
|
|
|
r = label_init("/dev");
|
|
|
|
if (r < 0) {
|
|
|
|
log_error("could not initialize labelling: %s", strerror(-r));
|
|
|
|
goto exit;
|
|
|
|
}
|
2014-09-15 11:53:03 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
/* set umask before creating any file/directory */
|
2014-09-18 19:07:02 +02:00
|
|
|
r = chdir("/");
|
|
|
|
if (r < 0) {
|
|
|
|
log_error("could not change dir to /: %m");
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
umask(022);
|
|
|
|
|
2014-09-18 19:07:02 +02:00
|
|
|
r = mkdir("/run/udev", 0755);
|
|
|
|
if (r < 0) {
|
|
|
|
log_error("could not create /run/udev: %m");
|
|
|
|
goto exit;
|
|
|
|
}
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2012-08-21 17:23:03 +02:00
|
|
|
dev_setup(NULL);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* before opening new files, make sure std{in,out,err} fds are in a sane state */
|
2014-09-12 14:42:59 +02:00
|
|
|
if (arg_daemonize) {
|
2012-01-10 01:34:15 +01:00
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open("/dev/null", O_RDWR);
|
|
|
|
if (fd >= 0) {
|
|
|
|
if (write(STDOUT_FILENO, 0, 0) < 0)
|
|
|
|
dup2(fd, STDOUT_FILENO);
|
|
|
|
if (write(STDERR_FILENO, 0, 0) < 0)
|
|
|
|
dup2(fd, STDERR_FILENO);
|
|
|
|
if (fd > STDERR_FILENO)
|
|
|
|
close(fd);
|
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("cannot open /dev/null");
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (systemd_fds(udev, &fd_ctrl, &fd_netlink) >= 0) {
|
2012-09-04 19:24:16 +02:00
|
|
|
/* get control and netlink socket from systemd */
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_ctrl = udev_ctrl_new_from_fd(udev, fd_ctrl);
|
|
|
|
if (udev_ctrl == NULL) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_error("error taking over udev control socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 1;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
monitor = udev_monitor_new_from_netlink_fd(udev, "kernel", fd_netlink);
|
|
|
|
if (monitor == NULL) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error taking over netlink socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 3;
|
|
|
|
goto exit;
|
|
|
|
}
|
2012-04-15 02:35:31 +02:00
|
|
|
|
|
|
|
/* get our own cgroup, we regularly kill everything udev has left behind */
|
2013-04-16 04:36:06 +02:00
|
|
|
if (cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 0, &udev_cgroup) < 0)
|
2012-04-15 02:35:31 +02:00
|
|
|
udev_cgroup = NULL;
|
2012-01-10 01:34:15 +01:00
|
|
|
} else {
|
|
|
|
/* open control and netlink socket */
|
|
|
|
udev_ctrl = udev_ctrl_new(udev);
|
|
|
|
if (udev_ctrl == NULL) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_error("error initializing udev control socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 1;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
fd_ctrl = udev_ctrl_get_fd(udev_ctrl);
|
|
|
|
|
|
|
|
monitor = udev_monitor_new_from_netlink(udev, "kernel");
|
|
|
|
if (monitor == NULL) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error initializing netlink socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 3;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
fd_netlink = udev_monitor_get_fd(monitor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_monitor_enable_receiving(monitor) < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error binding netlink socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 3;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (udev_ctrl_enable_receiving(udev_ctrl) < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error binding udev control socket");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 1;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2014-04-13 07:35:50 +02:00
|
|
|
udev_monitor_set_receive_buffer_size(monitor, 128 * 1024 * 1024);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2014-09-15 12:04:29 +02:00
|
|
|
log_info("starting version " VERSION "\n");
|
|
|
|
|
|
|
|
udev_builtin_init(udev);
|
|
|
|
|
|
|
|
rules = udev_rules_new(udev, arg_resolve_names);
|
|
|
|
if (rules == NULL) {
|
|
|
|
log_error("error reading rules");
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = udev_rules_apply_static_dev_perms(rules);
|
|
|
|
if (rc < 0)
|
|
|
|
log_error("failed to apply permissions on static device nodes - %s", strerror(-rc));
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
if (arg_daemonize) {
|
2012-01-10 01:34:15 +01:00
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
pid = fork();
|
|
|
|
switch (pid) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case -1:
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("fork of daemon failed: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 4;
|
|
|
|
goto exit;
|
|
|
|
default:
|
|
|
|
rc = EXIT_SUCCESS;
|
|
|
|
goto exit_daemonize;
|
|
|
|
}
|
|
|
|
|
|
|
|
setsid();
|
|
|
|
|
2013-04-02 20:31:42 +02:00
|
|
|
write_string_file("/proc/self/oom_score_adj", "-1000");
|
2012-01-10 01:34:15 +01:00
|
|
|
} else {
|
|
|
|
sd_notify(1, "READY=1");
|
|
|
|
}
|
|
|
|
|
2014-09-12 16:45:19 +02:00
|
|
|
if (arg_children_max <= 0) {
|
|
|
|
cpu_set_t cpu_set;
|
|
|
|
|
|
|
|
arg_children_max = 8;
|
|
|
|
|
|
|
|
if (sched_getaffinity(0, sizeof (cpu_set), &cpu_set) == 0) {
|
|
|
|
arg_children_max += CPU_COUNT(&cpu_set) * 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
log_debug("set children_max to %u", arg_children_max);
|
|
|
|
|
|
|
|
udev_list_node_init(&event_list);
|
|
|
|
udev_list_node_init(&worker_list);
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
fd_inotify = udev_watch_init(udev);
|
|
|
|
if (fd_inotify < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error initializing inotify");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 4;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
udev_watch_restore(udev);
|
|
|
|
|
|
|
|
/* block and listen to all signals on signalfd */
|
|
|
|
sigfillset(&mask);
|
|
|
|
sigprocmask(SIG_SETMASK, &mask, &sigmask_orig);
|
|
|
|
fd_signal = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
|
|
|
|
if (fd_signal < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error creating signalfd");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 5;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unnamed socket from workers to the main daemon */
|
|
|
|
if (socketpair(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0, worker_watch) < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error creating socketpair");
|
2012-01-10 01:34:15 +01:00
|
|
|
rc = 6;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
fd_worker = worker_watch[READ_END];
|
|
|
|
|
|
|
|
ep_ctrl.data.fd = fd_ctrl;
|
|
|
|
ep_inotify.data.fd = fd_inotify;
|
|
|
|
ep_signal.data.fd = fd_signal;
|
|
|
|
ep_netlink.data.fd = fd_netlink;
|
|
|
|
ep_worker.data.fd = fd_worker;
|
|
|
|
|
|
|
|
fd_ep = epoll_create1(EPOLL_CLOEXEC);
|
|
|
|
if (fd_ep < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("error creating epoll fd: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_ctrl, &ep_ctrl) < 0 ||
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_inotify, &ep_inotify) < 0 ||
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_signal, &ep_signal) < 0 ||
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_netlink, &ep_netlink) < 0 ||
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_worker, &ep_worker) < 0) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("fail to add fds to epoll: %m");
|
2012-01-10 01:34:15 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
2012-11-11 20:45:05 +01:00
|
|
|
static usec_t last_usec;
|
2012-01-10 01:34:15 +01:00
|
|
|
struct epoll_event ev[8];
|
|
|
|
int fdcount;
|
|
|
|
int timeout;
|
|
|
|
bool is_worker, is_signal, is_inotify, is_netlink, is_ctrl;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (udev_exit) {
|
|
|
|
/* close sources of new events and discard buffered events */
|
|
|
|
if (fd_ctrl >= 0) {
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_DEL, fd_ctrl, NULL);
|
|
|
|
fd_ctrl = -1;
|
|
|
|
}
|
|
|
|
if (monitor != NULL) {
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_DEL, fd_netlink, NULL);
|
|
|
|
udev_monitor_unref(monitor);
|
|
|
|
monitor = NULL;
|
|
|
|
}
|
|
|
|
if (fd_inotify >= 0) {
|
|
|
|
epoll_ctl(fd_ep, EPOLL_CTL_DEL, fd_inotify, NULL);
|
|
|
|
close(fd_inotify);
|
|
|
|
fd_inotify = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* discard queued events and kill workers */
|
|
|
|
event_queue_cleanup(udev, EVENT_QUEUED);
|
2012-04-15 02:35:31 +02:00
|
|
|
worker_kill(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* exit after all has cleaned up */
|
2014-04-13 07:35:50 +02:00
|
|
|
if (udev_list_node_is_empty(&event_list) && children == 0)
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* timeout at exit for workers to finish */
|
2014-04-13 07:35:50 +02:00
|
|
|
timeout = 30 * MSEC_PER_SEC;
|
|
|
|
} else if (udev_list_node_is_empty(&event_list) && children == 0) {
|
2012-01-18 05:06:18 +01:00
|
|
|
/* we are idle */
|
2012-01-10 01:34:15 +01:00
|
|
|
timeout = -1;
|
2012-04-15 02:35:31 +02:00
|
|
|
|
|
|
|
/* cleanup possible left-over processes in our cgroup */
|
|
|
|
if (udev_cgroup)
|
|
|
|
cg_kill(SYSTEMD_CGROUP_CONTROLLER, udev_cgroup, SIGKILL, false, true, NULL);
|
2012-01-18 05:06:18 +01:00
|
|
|
} else {
|
|
|
|
/* kill idle or hanging workers */
|
2014-04-13 07:35:50 +02:00
|
|
|
timeout = 3 * MSEC_PER_SEC;
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
2014-04-13 07:35:50 +02:00
|
|
|
|
|
|
|
/* tell settle that we are busy or idle */
|
|
|
|
if (!udev_list_node_is_empty(&event_list)) {
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open("/run/udev/queue", O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444);
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
} else {
|
|
|
|
unlink("/run/udev/queue");
|
|
|
|
}
|
|
|
|
|
2012-04-16 03:13:22 +02:00
|
|
|
fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), timeout);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (fdcount < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (fdcount == 0) {
|
2012-01-18 05:06:18 +01:00
|
|
|
struct udev_list_node *loop;
|
|
|
|
|
|
|
|
/* timeout */
|
2012-01-10 01:34:15 +01:00
|
|
|
if (udev_exit) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("timeout, giving up waiting for workers to finish");
|
2012-01-10 01:34:15 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-01-18 05:06:18 +01:00
|
|
|
/* kill idle workers */
|
|
|
|
if (udev_list_node_is_empty(&event_list)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("cleanup idle workers");
|
2012-04-15 02:35:31 +02:00
|
|
|
worker_kill(udev);
|
2012-01-18 05:06:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check for hanging events */
|
|
|
|
udev_list_node_foreach(loop, &worker_list) {
|
|
|
|
struct worker *worker = node_to_worker(loop);
|
2014-09-11 18:49:04 +02:00
|
|
|
usec_t ts;
|
2012-01-18 05:06:18 +01:00
|
|
|
|
|
|
|
if (worker->state != WORKER_RUNNING)
|
|
|
|
continue;
|
|
|
|
|
2014-09-11 18:49:04 +02:00
|
|
|
ts = now(CLOCK_MONOTONIC);
|
|
|
|
|
2014-09-12 14:42:59 +02:00
|
|
|
if ((ts - worker->event_start_usec) > arg_event_timeout_warn_usec) {
|
|
|
|
if ((ts - worker->event_start_usec) > arg_event_timeout_usec) {
|
2014-09-11 18:49:04 +02:00
|
|
|
log_error("worker [%u] %s timeout; kill it", worker->pid, worker->event->devpath);
|
|
|
|
kill(worker->pid, SIGKILL);
|
|
|
|
worker->state = WORKER_KILLED;
|
|
|
|
|
|
|
|
/* drop reference taken for state 'running' */
|
|
|
|
worker_unref(worker);
|
|
|
|
log_error("seq %llu '%s' killed", udev_device_get_seqnum(worker->event->dev), worker->event->devpath);
|
|
|
|
worker->event->exitcode = -64;
|
|
|
|
event_queue_delete(worker->event);
|
|
|
|
worker->event = NULL;
|
|
|
|
} else if (!worker->event_warned) {
|
|
|
|
log_warning("worker [%u] %s is taking a long time", worker->pid, worker->event->devpath);
|
|
|
|
worker->event_warned = true;
|
|
|
|
}
|
2012-01-18 05:06:18 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
is_worker = is_signal = is_inotify = is_netlink = is_ctrl = false;
|
|
|
|
for (i = 0; i < fdcount; i++) {
|
|
|
|
if (ev[i].data.fd == fd_worker && ev[i].events & EPOLLIN)
|
|
|
|
is_worker = true;
|
|
|
|
else if (ev[i].data.fd == fd_netlink && ev[i].events & EPOLLIN)
|
|
|
|
is_netlink = true;
|
|
|
|
else if (ev[i].data.fd == fd_signal && ev[i].events & EPOLLIN)
|
|
|
|
is_signal = true;
|
|
|
|
else if (ev[i].data.fd == fd_inotify && ev[i].events & EPOLLIN)
|
|
|
|
is_inotify = true;
|
|
|
|
else if (ev[i].data.fd == fd_ctrl && ev[i].events & EPOLLIN)
|
|
|
|
is_ctrl = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for changed config, every 3 seconds at most */
|
2014-04-13 07:35:50 +02:00
|
|
|
if ((now(CLOCK_MONOTONIC) - last_usec) > 3 * USEC_PER_SEC) {
|
2012-04-16 17:21:22 +02:00
|
|
|
if (udev_rules_check_timestamp(rules))
|
2012-01-10 01:34:15 +01:00
|
|
|
reload = true;
|
|
|
|
if (udev_builtin_validate(udev))
|
|
|
|
reload = true;
|
|
|
|
|
2012-11-11 20:45:05 +01:00
|
|
|
last_usec = now(CLOCK_MONOTONIC);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reload requested, HUP signal received, rules changed, builtin changed */
|
|
|
|
if (reload) {
|
2012-04-15 02:35:31 +02:00
|
|
|
worker_kill(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
rules = udev_rules_unref(rules);
|
|
|
|
udev_builtin_exit(udev);
|
2012-08-08 16:27:11 +02:00
|
|
|
reload = false;
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* event has finished */
|
|
|
|
if (is_worker)
|
|
|
|
worker_returned(fd_worker);
|
|
|
|
|
|
|
|
if (is_netlink) {
|
|
|
|
struct udev_device *dev;
|
|
|
|
|
|
|
|
dev = udev_monitor_receive_device(monitor);
|
|
|
|
if (dev != NULL) {
|
2012-11-11 20:45:05 +01:00
|
|
|
udev_device_set_usec_initialized(dev, now(CLOCK_MONOTONIC));
|
2012-01-10 01:34:15 +01:00
|
|
|
if (event_queue_insert(dev) < 0)
|
|
|
|
udev_device_unref(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* start new events */
|
|
|
|
if (!udev_list_node_is_empty(&event_list) && !udev_exit && !stop_exec_queue) {
|
2012-08-08 16:27:11 +02:00
|
|
|
udev_builtin_init(udev);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (rules == NULL)
|
2014-09-12 14:42:59 +02:00
|
|
|
rules = udev_rules_new(udev, arg_resolve_names);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (rules != NULL)
|
|
|
|
event_queue_start(udev);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_signal) {
|
|
|
|
struct signalfd_siginfo fdsi;
|
|
|
|
ssize_t size;
|
|
|
|
|
|
|
|
size = read(fd_signal, &fdsi, sizeof(struct signalfd_siginfo));
|
|
|
|
if (size == sizeof(struct signalfd_siginfo))
|
|
|
|
handle_signal(udev, fdsi.ssi_signo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we are shutting down, the events below are not handled anymore */
|
|
|
|
if (udev_exit)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* device node watch */
|
|
|
|
if (is_inotify)
|
|
|
|
handle_inotify(udev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This needs to be after the inotify handling, to make sure,
|
|
|
|
* that the ping is send back after the possibly generated
|
|
|
|
* "change" events by the inotify device node watch.
|
|
|
|
*
|
|
|
|
* A single time we may receive a client connection which we need to
|
|
|
|
* keep open to block the client. It will be closed right before we
|
|
|
|
* exit.
|
|
|
|
*/
|
|
|
|
if (is_ctrl)
|
|
|
|
ctrl_conn = handle_ctrl_msg(udev_ctrl);
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = EXIT_SUCCESS;
|
[PATCH] udevd - cleanup and better timeout handling
On Thu, Jan 29, 2004 at 04:55:11PM +0100, Kay Sievers wrote:
> On Thu, Jan 29, 2004 at 02:56:25AM +0100, Kay Sievers wrote:
> > On Wed, Jan 28, 2004 at 10:47:36PM +0100, Kay Sievers wrote:
> > > Oh, couldn't resist to try threads.
> > > It's a multithreaded udevd that communicates through a localhost socket.
> > > The message includes a magic with the udev version, so we don't accept
> > > older udevsend's.
> > >
> > > No need for locking, cause we can't bind two sockets on the same address.
> > > The daemon tries to connect and if it fails it starts the daemon.
> > >
> > > We create a thread for every incoming connection, handle over the socket,
> > > sort the messages in the global message queue and exit the thread.
> > > Huh, that was easy with threads :)
> > >
> > > With the addition of a message we wakeup the queue manager thread and
> > > handle timeouts or move the message to the global exec list. This wakes
> > > up the exec list manager who looks if a process is already running for this
> > > device path.
> > > If yes, the exec is delayed otherwise we create a thread that execs udev.
> > > n the background. With the return of udev we free the message and wakeup
> > > the exec list manager to look if something is pending.
> > >
> > > It is just a quick shot, cause I couldn't solve the problems with fork an
> > > scheduling and I wanted to see if I'm to stupid :)
> > > But if anybody with a better idea or more experience with I/O scheduling
> > > we may go another way. The remaining problem is that klibc doesn't support
> > > threads.
> > >
> > > By now, we don't exec anything, it's just a sleep 3 for every exec,
> > > but you can see the queue management by watching syslog and do:
> > >
> > > DEVPATH=/abc ACTION=add SEQNUM=0 ./udevsend /abc
>
> Next version, switched to unix domain sockets.
Next cleaned up version. Hey, nobody wants to try it :)
Works for me, It's funny if I connect/disconnect my 4in1-usb-flash-reader
every two seconds. The 2.6 usb rocks! I can connect/diconnect a hub with 3
devices plugged in every second and don't run into any problem but a _very_
big udevd queue.
2004-02-01 18:12:36 +01:00
|
|
|
exit:
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_ctrl_cleanup(udev_ctrl);
|
2014-04-13 07:35:50 +02:00
|
|
|
unlink("/run/udev/queue");
|
2011-10-10 00:38:56 +02:00
|
|
|
exit_daemonize:
|
2012-01-10 01:34:15 +01:00
|
|
|
if (fd_ep >= 0)
|
|
|
|
close(fd_ep);
|
|
|
|
worker_list_cleanup(udev);
|
|
|
|
event_queue_cleanup(udev, EVENT_UNDEF);
|
|
|
|
udev_rules_unref(rules);
|
|
|
|
udev_builtin_exit(udev);
|
|
|
|
if (fd_signal >= 0)
|
|
|
|
close(fd_signal);
|
|
|
|
if (worker_watch[READ_END] >= 0)
|
|
|
|
close(worker_watch[READ_END]);
|
|
|
|
if (worker_watch[WRITE_END] >= 0)
|
|
|
|
close(worker_watch[WRITE_END]);
|
|
|
|
udev_monitor_unref(monitor);
|
|
|
|
udev_ctrl_connection_unref(ctrl_conn);
|
|
|
|
udev_ctrl_unref(udev_ctrl);
|
2012-04-17 16:05:03 +02:00
|
|
|
label_finish();
|
2012-01-10 01:34:15 +01:00
|
|
|
udev_unref(udev);
|
2012-04-08 16:06:20 +02:00
|
|
|
log_close();
|
2012-01-10 01:34:15 +01:00
|
|
|
return rc;
|
[PATCH] spilt udev into pieces
On Thu, Jan 22, 2004 at 01:27:45AM +0100, Kay Sievers wrote:
> On Wed, Jan 21, 2004 at 02:38:25PM +0100, Kay Sievers wrote:
> > On Thu, Jan 15, 2004 at 01:45:10PM -0800, Greg KH wrote:
> > > On Thu, Jan 15, 2004 at 10:36:25PM +0800, Ling, Xiaofeng wrote:
> > > > Hi, Greg
> > > > I wrote a simple implementation for the two pieces
> > > > of send and receive hotplug event,
> > > > use a message queue and a list for the out of order
> > > > hotplug event. It also has a timeout timer of 3 seconds.
> > > > They are now separate program. the file nseq is the test script.
> > > > Could you have a look to see wether it is feasible?
> > > > If so, I'll continue to merge with udev.
> > >
> > > Yes, very nice start. Please continue on.
> > >
> > > One minor comment, please stick with the kernel coding style when you
> > > are writing new code for udev.
> >
> > I took the code from Xiaofeng, cleaned the whitespace, renamed some bits,
> > tweaked the debugging, added the udev exec and created a patch for the current tree.
> >
> > It seems functional now, by simply executing our current udev (dirty hack).
> > It reorders the incoming events and if one is missing it delays the
> > execution of the following ones up to a maximum of 10 seconds.
> >
> > Test script is included, but you can't mix hotplug sequence numbers and
> > test script numbers, it will result in waiting for the missing numbers :)
>
> Hey, nobody want's to play with me?
> So here I'm chatting with myself :)
>
> This is the next version with signal handling for resetting the expected
> signal number. I changed the behaviour of the timeout to skip all
> missing events at once and to proceed with the next event in the queue.
>
> So it's now possible to use the test script at any time, cause it resets
> the daemon, if real hotplug event coming in later all missing nimbers will
> be skipped after a timeout of 10 seconds and the queued events are applied.
Here is the next updated updated version to apply to the lastet udev.
I've added infrastructure for getting the state of the IPC queue in the
sender and set the program to exec by the daemon. Also the magic key id
is replaced by the usual key generation by path/nr.
It looks promising, I use it on my machine and my 4in1 USB-flash-reader
connect/disconnect emits the events "randomly" but udevd is able to
reorder it and calls our normal udev in the right order.
2004-01-23 09:28:57 +01:00
|
|
|
}
|