2003-07-17 12:24:51 +04:00
/*
* Copyright ( C ) 2003 Greg Kroah - Hartman < greg @ kroah . com >
2006-04-28 19:52:09 +04:00
* Copyright ( C ) 2003 - 2006 Kay Sievers < kay . sievers @ vrfy . org >
2003-07-17 12:24:51 +04: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 version 2 of the License .
2006-04-28 19:52:09 +04:00
*
2003-07-17 12:24:51 +04: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 .
2006-04-28 19:52:09 +04:00
*
2003-07-17 12:24:51 +04:00
* You should have received a copy of the GNU General Public License along
* with this program ; if not , write to the Free Software Foundation , Inc . ,
2006-08-28 02:29:11 +04:00
* 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 , USA .
2003-07-17 12:24:51 +04:00
*
*/
# include <stddef.h>
# include <stdlib.h>
# include <string.h>
# include <stdio.h>
# include <fcntl.h>
# include <ctype.h>
# include <unistd.h>
# include <errno.h>
2005-08-11 19:32:59 +04:00
# include <syslog.h>
2006-08-24 11:03:15 +04:00
# include <fnmatch.h>
2003-10-15 10:32:17 +04:00
# include <sys/wait.h>
2005-07-08 01:01:04 +04:00
# include <sys/stat.h>
2003-07-17 12:24:51 +04:00
# include "udev.h"
2005-03-13 00:36:32 +03:00
# include "udev_rules.h"
2003-07-17 12:24:51 +04:00
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
/* extract possible {attr} and move str behind it */
static char * get_format_attribute ( char * * str )
{
char * pos ;
char * attr = NULL ;
if ( * str [ 0 ] = = ' { ' ) {
pos = strchr ( * str , ' } ' ) ;
if ( pos = = NULL ) {
2005-03-27 03:11:03 +04:00
err ( " missing closing brace for format " ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
return NULL ;
}
pos [ 0 ] = ' \0 ' ;
attr = * str + 1 ;
* str = pos + 1 ;
dbg ( " attribute='%s', str='%s' " , attr , * str ) ;
}
return attr ;
}
/* extract possible format length and move str behind it*/
static int get_format_len ( char * * str )
{
int num ;
char * tail ;
if ( isdigit ( * str [ 0 ] ) ) {
num = ( int ) strtoul ( * str , & tail , 10 ) ;
2004-03-02 10:17:59 +03:00
if ( num > 0 ) {
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
* str = tail ;
dbg ( " format length=%i " , num ) ;
return num ;
} else {
2005-03-27 03:11:03 +04:00
err ( " format parsing error '%s' " , * str ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
}
}
return - 1 ;
}
2005-06-25 15:10:16 +04:00
static int get_key ( char * * line , char * * key , char * * value )
{
char * linepos ;
char * temp ;
linepos = * line ;
2007-05-16 21:51:13 +04:00
if ( linepos = = NULL )
2005-06-25 15:10:16 +04:00
return - 1 ;
/* skip whitespace */
while ( isspace ( linepos [ 0 ] ) )
linepos + + ;
/* get the key */
2007-05-21 10:00:09 +04:00
temp = strchr ( linepos , ' = ' ) ;
if ( temp = = NULL | | temp = = linepos )
return - 1 ;
temp [ 0 ] = ' \0 ' ;
2005-06-25 15:10:16 +04:00
* key = linepos ;
2007-05-21 10:00:09 +04:00
linepos = & temp [ 1 ] ;
/* get a quoted value */
if ( linepos [ 0 ] = = ' " ' | | linepos [ 0 ] = = ' \' ' ) {
temp = strchr ( & linepos [ 1 ] , linepos [ 0 ] ) ;
if ( temp ! = NULL ) {
temp [ 0 ] = ' \0 ' ;
* value = & linepos [ 1 ] ;
goto out ;
}
2005-06-25 15:10:16 +04:00
}
/* get the value*/
2007-05-21 10:00:09 +04:00
temp = strchr ( linepos , ' \n ' ) ;
if ( temp ! = NULL )
2005-06-25 15:10:16 +04:00
temp [ 0 ] = ' \0 ' ;
* value = linepos ;
2007-05-21 10:00:09 +04:00
out :
2005-06-25 15:10:16 +04:00
return 0 ;
}
2005-06-26 20:55:24 +04:00
static int import_keys_into_env ( struct udevice * udev , const char * buf , size_t bufsize )
2005-06-25 15:10:16 +04:00
{
char line [ LINE_SIZE ] ;
2005-06-25 17:35:14 +04:00
const char * bufline ;
2005-06-25 15:10:16 +04:00
char * linepos ;
char * variable ;
char * value ;
size_t cur ;
size_t count ;
int lineno ;
2005-06-26 20:55:24 +04:00
/* loop through the whole buffer */
2005-06-25 15:10:16 +04:00
lineno = 0 ;
cur = 0 ;
while ( cur < bufsize ) {
count = buf_get_line ( buf , bufsize , cur ) ;
bufline = & buf [ cur ] ;
cur + = count + 1 ;
lineno + + ;
if ( count > = sizeof ( line ) ) {
err ( " line too long, conf line skipped %s, line %d " , udev_config_filename , lineno ) ;
continue ;
}
/* eat the whitespace */
while ( ( count > 0 ) & & isspace ( bufline [ 0 ] ) ) {
bufline + + ;
count - - ;
}
if ( count = = 0 )
continue ;
/* see if this is a comment */
if ( bufline [ 0 ] = = COMMENT_CHARACTER )
continue ;
2005-08-08 04:21:55 +04:00
memcpy ( line , bufline , count ) ;
line [ count ] = ' \0 ' ;
2005-06-25 15:10:16 +04:00
linepos = line ;
if ( get_key ( & linepos , & variable , & value ) = = 0 ) {
2005-06-25 20:58:49 +04:00
dbg ( " import '%s=%s' " , variable , value ) ;
2007-03-15 02:10:22 +03:00
/* handle device, renamed by external tool, returning new path */
if ( strcmp ( variable , " DEVPATH " ) = = 0 ) {
info ( " updating devpath from '%s' to '%s' " , udev - > dev - > devpath , value ) ;
sysfs_device_set_values ( udev - > dev , value , NULL , NULL ) ;
} else
name_list_key_add ( & udev - > env_list , variable , value ) ;
2005-06-25 20:58:49 +04:00
setenv ( variable , value , 1 ) ;
2005-06-25 15:10:16 +04:00
}
}
2005-06-25 17:35:14 +04:00
return 0 ;
}
2005-06-26 20:55:24 +04:00
static int import_file_into_env ( struct udevice * udev , const char * filename )
2005-06-25 17:35:14 +04:00
{
char * buf ;
size_t bufsize ;
if ( file_map ( filename , & buf , & bufsize ) ! = 0 ) {
2005-11-07 20:44:18 +03:00
err ( " can't open '%s': %s " , filename , strerror ( errno ) ) ;
2005-06-25 17:35:14 +04:00
return - 1 ;
}
2005-06-26 20:55:24 +04:00
import_keys_into_env ( udev , buf , bufsize ) ;
2005-06-25 15:10:16 +04:00
file_unmap ( buf , bufsize ) ;
2005-06-25 17:35:14 +04:00
return 0 ;
2005-06-25 15:10:16 +04:00
}
2005-06-25 20:58:49 +04:00
static int import_program_into_env ( struct udevice * udev , const char * program )
{
2007-05-16 21:51:13 +04:00
char result [ 2048 ] ;
2005-06-25 20:58:49 +04:00
size_t reslen ;
2006-01-09 23:18:00 +03:00
if ( run_program ( program , udev - > dev - > subsystem , result , sizeof ( result ) , & reslen , ( udev_log_priority > = LOG_INFO ) ) ! = 0 )
2005-06-25 20:58:49 +04:00
return - 1 ;
2005-06-26 20:55:24 +04:00
return import_keys_into_env ( udev , result , reslen ) ;
2005-06-25 20:58:49 +04:00
}
2006-01-09 23:18:00 +03:00
static int import_parent_into_env ( struct udevice * udev , const char * filter )
2005-07-12 16:46:36 +04:00
{
2006-01-09 23:18:00 +03:00
struct sysfs_device * dev_parent ;
2005-07-12 16:46:36 +04:00
int rc = - 1 ;
2006-01-09 23:18:00 +03:00
dev_parent = sysfs_device_get_parent ( udev - > dev ) ;
if ( dev_parent ! = NULL ) {
struct udevice * udev_parent ;
2005-07-12 16:46:36 +04:00
struct name_entry * name_loop ;
2006-01-09 23:18:00 +03:00
dbg ( " found parent '%s', get the node name " , dev_parent - > devpath ) ;
2007-03-17 12:08:25 +03:00
udev_parent = udev_device_init ( NULL ) ;
2006-01-09 23:18:00 +03:00
if ( udev_parent = = NULL )
return - 1 ;
2005-07-12 16:46:36 +04:00
/* import the udev_db of the parent */
2006-01-09 23:18:00 +03:00
if ( udev_db_get_device ( udev_parent , dev_parent - > devpath ) = = 0 ) {
dbg ( " import stored parent env '%s' " , udev_parent - > name ) ;
list_for_each_entry ( name_loop , & udev_parent - > env_list , node ) {
2005-07-12 16:46:36 +04:00
char name [ NAME_SIZE ] ;
char * pos ;
strlcpy ( name , name_loop - > name , sizeof ( name ) ) ;
pos = strchr ( name , ' = ' ) ;
if ( pos ) {
pos [ 0 ] = ' \0 ' ;
pos + + ;
2006-08-24 11:03:15 +04:00
if ( fnmatch ( filter , name , 0 ) = = 0 ) {
2005-07-12 16:46:36 +04:00
dbg ( " import key '%s' " , name_loop - > name ) ;
name_list_add ( & udev - > env_list , name_loop - > name , 0 ) ;
setenv ( name , pos , 1 ) ;
} else
dbg ( " skip key '%s' " , name_loop - > name ) ;
}
}
rc = 0 ;
} else
dbg ( " parent not found in database " ) ;
2006-01-09 23:18:00 +03:00
udev_device_cleanup ( udev_parent ) ;
2005-07-12 16:46:36 +04:00
}
return rc ;
}
2005-11-12 06:17:48 +03:00
# define WAIT_LOOP_PER_SECOND 50
2005-07-07 22:05:51 +04:00
static int wait_for_sysfs ( struct udevice * udev , const char * file , int timeout )
{
2006-02-15 22:43:28 +03:00
char devicepath [ PATH_SIZE ] ;
char filepath [ PATH_SIZE ] ;
2005-07-07 22:05:51 +04:00
struct stat stats ;
int loop = timeout * WAIT_LOOP_PER_SECOND ;
2006-02-15 22:43:28 +03:00
strlcpy ( devicepath , sysfs_path , sizeof ( devicepath ) ) ;
strlcat ( devicepath , udev - > dev - > devpath , sizeof ( devicepath ) ) ;
strlcpy ( filepath , devicepath , sizeof ( filepath ) ) ;
strlcat ( filepath , " / " , sizeof ( filepath ) ) ;
strlcat ( filepath , file , sizeof ( filepath ) ) ;
2005-07-07 22:05:51 +04:00
2006-02-15 22:43:28 +03:00
dbg ( " will wait %i sec for '%s' " , timeout , filepath ) ;
2005-07-07 22:05:51 +04:00
while ( - - loop ) {
2006-02-15 22:43:28 +03:00
/* lookup file */
if ( stat ( filepath , & stats ) = = 0 ) {
info ( " file '%s' appeared after %i loops " , filepath , ( timeout * WAIT_LOOP_PER_SECOND ) - loop - 1 ) ;
2005-07-07 22:05:51 +04:00
return 0 ;
}
2007-03-19 11:56:53 +03:00
/* make sure, the device did not disappear in the meantime */
2006-02-15 22:43:28 +03:00
if ( stat ( devicepath , & stats ) ! = 0 ) {
info ( " device disappeared while waiting for '%s' " , filepath ) ;
return - 2 ;
}
info ( " wait for '%s' for %i mseconds " , filepath , 1000 / WAIT_LOOP_PER_SECOND ) ;
2005-07-07 22:05:51 +04:00
usleep ( 1000 * 1000 / WAIT_LOOP_PER_SECOND ) ;
}
2007-06-03 14:29:46 +04:00
info ( " waiting for '%s' failed " , filepath ) ;
2005-07-07 22:05:51 +04:00
return - 1 ;
}
2007-06-03 14:29:46 +04:00
/* handle "[$SUBSYSTEM/$KERNEL]<attribute>" lookup */
static int attr_get_by_subsys_id ( const char * attrstr , char * devpath , size_t len , char * * attr )
{
char subsys [ NAME_SIZE ] ;
char * attrib ;
char * id ;
int found = 0 ;
if ( attrstr [ 0 ] ! = ' [ ' )
goto out ;
strlcpy ( subsys , & attrstr [ 1 ] , sizeof ( subsys ) ) ;
attrib = strchr ( subsys , ' ] ' ) ;
if ( attrib = = NULL )
goto out ;
attrib [ 0 ] = ' \0 ' ;
attrib = & attrib [ 1 ] ;
id = strchr ( subsys , ' / ' ) ;
if ( id = = NULL )
goto out ;
id [ 0 ] = ' \0 ' ;
id = & id [ 1 ] ;
if ( sysfs_lookup_devpath_by_subsys_id ( devpath , len , subsys , id ) ) {
if ( attr ! = NULL ) {
if ( attrib [ 0 ] ! = ' \0 ' )
* attr = attrib ;
else
* attr = NULL ;
}
found = 1 ;
}
out :
return found ;
}
2006-01-25 03:28:31 +03:00
void udev_rules_apply_format ( struct udevice * udev , char * string , size_t maxsize )
2003-11-24 09:25:13 +03:00
{
2005-03-07 06:29:43 +03:00
char temp [ PATH_SIZE ] ;
char temp2 [ PATH_SIZE ] ;
2005-06-25 15:10:16 +04:00
char * head , * tail , * pos , * cpos , * attr , * rest ;
2004-02-28 17:53:25 +03:00
int len ;
2004-02-17 12:29:03 +03:00
int i ;
2005-08-28 17:55:58 +04:00
int count ;
2005-06-20 02:29:38 +04:00
enum subst_type {
SUBST_UNKNOWN ,
SUBST_DEVPATH ,
2006-08-19 18:06:25 +04:00
SUBST_KERNEL ,
2005-06-20 02:29:38 +04:00
SUBST_KERNEL_NUMBER ,
2006-01-16 08:12:49 +03:00
SUBST_ID ,
2005-06-20 02:29:38 +04:00
SUBST_MAJOR ,
SUBST_MINOR ,
SUBST_RESULT ,
2006-08-19 18:06:25 +04:00
SUBST_ATTR ,
2005-06-20 02:29:38 +04:00
SUBST_PARENT ,
SUBST_TEMP_NODE ,
SUBST_ROOT ,
2007-06-03 00:06:01 +04:00
SUBST_SYS ,
2005-06-25 15:10:16 +04:00
SUBST_ENV ,
2005-06-20 02:29:38 +04:00
} ;
static const struct subst_map {
char * name ;
char fmt ;
enum subst_type type ;
} map [ ] = {
2006-08-19 18:06:25 +04:00
{ . name = " devpath " , . fmt = ' p ' , . type = SUBST_DEVPATH } ,
{ . name = " number " , . fmt = ' n ' , . type = SUBST_KERNEL_NUMBER } ,
{ . name = " kernel " , . fmt = ' k ' , . type = SUBST_KERNEL } ,
{ . name = " id " , . fmt = ' b ' , . type = SUBST_ID } ,
{ . name = " major " , . fmt = ' M ' , . type = SUBST_MAJOR } ,
{ . name = " minor " , . fmt = ' m ' , . type = SUBST_MINOR } ,
{ . name = " result " , . fmt = ' c ' , . type = SUBST_RESULT } ,
{ . name = " attr " , . fmt = ' s ' , . type = SUBST_ATTR } ,
{ . name = " sysfs " , . fmt = ' s ' , . type = SUBST_ATTR } ,
{ . name = " parent " , . fmt = ' P ' , . type = SUBST_PARENT } ,
{ . name = " tempnode " , . fmt = ' N ' , . type = SUBST_TEMP_NODE } ,
{ . name = " root " , . fmt = ' r ' , . type = SUBST_ROOT } ,
2007-06-03 00:06:01 +04:00
{ . name = " sys " , . fmt = ' S ' , . type = SUBST_SYS } ,
2006-08-19 18:06:25 +04:00
{ . name = " env " , . fmt = ' E ' , . type = SUBST_ENV } ,
2005-08-13 02:18:44 +04:00
{ NULL , ' \0 ' , 0 }
2005-06-20 02:29:38 +04:00
} ;
enum subst_type type ;
const struct subst_map * subst ;
head = string ;
2003-11-24 09:25:13 +03:00
while ( 1 ) {
2005-06-20 02:29:38 +04:00
len = - 1 ;
while ( head [ 0 ] ! = ' \0 ' ) {
if ( head [ 0 ] = = ' $ ' ) {
/* substitute named variable */
if ( head [ 1 ] = = ' \0 ' )
break ;
if ( head [ 1 ] = = ' $ ' ) {
strlcpy ( temp , head + 2 , sizeof ( temp ) ) ;
strlcpy ( head + 1 , temp , maxsize ) ;
head + + ;
continue ;
}
head [ 0 ] = ' \0 ' ;
for ( subst = map ; subst - > name ; subst + + ) {
if ( strncasecmp ( & head [ 1 ] , subst - > name , strlen ( subst - > name ) ) = = 0 ) {
type = subst - > type ;
tail = head + strlen ( subst - > name ) + 1 ;
dbg ( " will substitute format name '%s' " , subst - > name ) ;
goto found ;
}
}
2007-02-01 22:18:52 +03:00
head [ 0 ] = ' $ ' ;
err ( " unknown format variable '%s' " , head ) ;
2006-04-28 19:52:09 +04:00
} else if ( head [ 0 ] = = ' % ' ) {
2005-06-20 02:29:38 +04:00
/* substitute format char */
if ( head [ 1 ] = = ' \0 ' )
break ;
if ( head [ 1 ] = = ' % ' ) {
strlcpy ( temp , head + 2 , sizeof ( temp ) ) ;
strlcpy ( head + 1 , temp , maxsize ) ;
head + + ;
continue ;
}
head [ 0 ] = ' \0 ' ;
tail = head + 1 ;
len = get_format_len ( & tail ) ;
for ( subst = map ; subst - > name ; subst + + ) {
if ( tail [ 0 ] = = subst - > fmt ) {
type = subst - > type ;
tail + + ;
dbg ( " will substitute format char '%c' " , subst - > fmt ) ;
goto found ;
}
}
2007-02-01 22:18:52 +03:00
head [ 0 ] = ' % ' ;
err ( " unknown format char '%c' " , tail [ 0 ] ) ;
2005-06-20 02:29:38 +04:00
}
head + + ;
}
break ;
found :
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
attr = get_format_attribute ( & tail ) ;
2005-06-20 02:29:38 +04:00
strlcpy ( temp , tail , sizeof ( temp ) ) ;
2006-01-09 23:18:00 +03:00
dbg ( " format=%i, string='%s', tail='%s' " , type , string , tail ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
2005-06-20 02:29:38 +04:00
switch ( type ) {
case SUBST_DEVPATH :
2006-01-09 23:18:00 +03:00
strlcat ( string , udev - > dev - > devpath , maxsize ) ;
dbg ( " substitute devpath '%s' " , udev - > dev - > devpath ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
2006-08-19 18:06:25 +04:00
case SUBST_KERNEL :
strlcat ( string , udev - > dev - > kernel , maxsize ) ;
dbg ( " substitute kernel name '%s' " , udev - > dev - > kernel ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
2005-06-20 02:29:38 +04:00
case SUBST_KERNEL_NUMBER :
2006-01-09 23:18:00 +03:00
strlcat ( string , udev - > dev - > kernel_number , maxsize ) ;
dbg ( " substitute kernel number '%s' " , udev - > dev - > kernel_number ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
2006-01-16 08:12:49 +03:00
case SUBST_ID :
if ( udev - > dev_parent ! = NULL ) {
2006-08-19 18:06:25 +04:00
strlcat ( string , udev - > dev_parent - > kernel , maxsize ) ;
dbg ( " substitute id '%s' " , udev - > dev_parent - > kernel ) ;
2006-01-16 08:12:49 +03:00
}
break ;
2005-06-20 02:29:38 +04:00
case SUBST_MAJOR :
2005-03-05 08:50:09 +03:00
sprintf ( temp2 , " %d " , major ( udev - > devt ) ) ;
2005-03-07 06:29:43 +03:00
strlcat ( string , temp2 , maxsize ) ;
2005-03-05 08:50:09 +03:00
dbg ( " substitute major number '%s' " , temp2 ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
2005-06-20 02:29:38 +04:00
case SUBST_MINOR :
sprintf ( temp2 , " %d " , minor ( udev - > devt ) ) ;
strlcat ( string , temp2 , maxsize ) ;
dbg ( " substitute minor number '%s' " , temp2 ) ;
break ;
case SUBST_RESULT :
2005-03-04 22:52:19 +03:00
if ( udev - > program_result [ 0 ] = = ' \0 ' )
2003-11-24 09:25:13 +03:00
break ;
2004-02-17 12:29:03 +03:00
/* get part part of the result string */
2004-02-28 17:53:25 +03:00
i = 0 ;
2004-02-17 12:29:03 +03:00
if ( attr ! = NULL )
2004-03-11 12:37:18 +03:00
i = strtoul ( attr , & rest , 10 ) ;
2004-02-17 12:29:03 +03:00
if ( i > 0 ) {
2005-03-05 08:50:09 +03:00
dbg ( " request part #%d of result string " , i ) ;
cpos = udev - > program_result ;
while ( - - i ) {
while ( cpos [ 0 ] ! = ' \0 ' & & ! isspace ( cpos [ 0 ] ) )
cpos + + ;
while ( isspace ( cpos [ 0 ] ) )
cpos + + ;
[PATCH] get part of callout return string
Try this patch if you like, to get special parts of the callout output.
This beast works now:
CALLOUT, BUS="scsi", PROGRAM="/bin/echo -n node link1 link2", ID="node *", NAME="%1c", SYMLINK="%2c %3c"
The callout returned string is separated by spaces and is
addressed by the "len" value of the 'c' format char.
Since we support symlinks, this my be useful for other uses of callout too.
introduce 'len number' for format chars
the first use is 'c'-the callout return to select a part of the output string like:
CALLOUT, BUS="scsi", PROGRAM="/bin/echo -n node link1 link2", ID="node *", NAME="%1c", SYMLINK="%2c %3c"
(note: first part is requested by len=1, len=0 will return the whole string)
add a test to udev-test.pl
2003-12-16 09:54:38 +03:00
}
2004-03-04 05:16:35 +03:00
if ( i > 0 ) {
2005-03-27 03:11:03 +04:00
err ( " requested part of result string not found " ) ;
2004-03-04 05:16:35 +03:00
break ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
}
2005-03-07 06:29:43 +03:00
strlcpy ( temp2 , cpos , sizeof ( temp2 ) ) ;
2005-03-05 08:50:09 +03:00
/* %{2+}c copies the whole string from the second part on */
if ( rest [ 0 ] ! = ' + ' ) {
cpos = strchr ( temp2 , ' ' ) ;
if ( cpos )
cpos [ 0 ] = ' \0 ' ;
}
2005-03-07 06:29:43 +03:00
strlcat ( string , temp2 , maxsize ) ;
2004-03-04 11:54:13 +03:00
dbg ( " substitute part of result string '%s' " , temp2 ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
} else {
2005-03-07 06:29:43 +03:00
strlcat ( string , udev - > program_result , maxsize ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
dbg ( " substitute result string '%s' " , udev - > program_result ) ;
2003-11-24 09:25:13 +03:00
}
break ;
2006-08-19 18:06:25 +04:00
case SUBST_ATTR :
2006-09-05 04:18:06 +04:00
if ( attr = = NULL )
err ( " missing file parameter for attr " ) ;
else {
2007-06-03 14:29:46 +04:00
char devpath [ PATH_SIZE ] ;
char * attrib ;
2006-09-05 04:18:06 +04:00
const char * value = NULL ;
size_t size ;
2007-06-03 14:29:46 +04:00
if ( attr_get_by_subsys_id ( attr , devpath , sizeof ( devpath ) , & attrib ) ) {
if ( attrib ! = NULL )
value = sysfs_attr_get_value ( devpath , attrib ) ;
else
break ;
}
/* try the current device, other matches may have selected */
if ( value = = NULL & & udev - > dev_parent ! = NULL & & udev - > dev_parent ! = udev - > dev )
2006-09-05 04:18:06 +04:00
value = sysfs_attr_get_value ( udev - > dev_parent - > devpath , attr ) ;
/* look at all devices along the chain of parents */
if ( value = = NULL ) {
struct sysfs_device * dev_parent = udev - > dev ;
do {
dbg ( " looking at '%s' " , dev_parent - > devpath ) ;
value = sysfs_attr_get_value ( dev_parent - > devpath , attr ) ;
if ( value ! = NULL ) {
strlcpy ( temp2 , value , sizeof ( temp2 ) ) ;
break ;
}
dev_parent = sysfs_device_get_parent ( dev_parent ) ;
} while ( dev_parent ! = NULL ) ;
}
2006-01-09 23:18:00 +03:00
2006-09-05 04:18:06 +04:00
if ( value = = NULL )
break ;
2006-01-09 23:18:00 +03:00
2007-05-17 22:01:54 +04:00
/* strip trailing whitespace, and replace unwanted characters */
2006-09-05 04:18:06 +04:00
size = strlcpy ( temp2 , value , sizeof ( temp2 ) ) ;
if ( size > = sizeof ( temp2 ) )
size = sizeof ( temp2 ) - 1 ;
while ( size > 0 & & isspace ( temp2 [ size - 1 ] ) )
temp2 [ - - size ] = ' \0 ' ;
2007-05-17 22:01:54 +04:00
count = replace_chars ( temp2 , ALLOWED_CHARS_INPUT ) ;
2006-09-05 04:18:06 +04:00
if ( count > 0 )
2007-05-17 22:01:54 +04:00
info ( " %i character(s) replaced " , count ) ;
2006-01-09 23:18:00 +03:00
strlcat ( string , temp2 , maxsize ) ;
dbg ( " substitute sysfs value '%s' " , temp2 ) ;
2005-02-21 16:01:23 +03:00
}
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
2005-06-20 02:29:38 +04:00
case SUBST_PARENT :
2006-01-09 23:18:00 +03:00
{
struct sysfs_device * dev_parent ;
dev_parent = sysfs_device_get_parent ( udev - > dev ) ;
if ( dev_parent ! = NULL ) {
struct udevice * udev_parent ;
dbg ( " found parent '%s', get the node name " , dev_parent - > devpath ) ;
2007-03-17 12:08:25 +03:00
udev_parent = udev_device_init ( NULL ) ;
2006-01-09 23:18:00 +03:00
if ( udev_parent ! = NULL ) {
/* lookup the name in the udev_db with the DEVPATH of the parent */
if ( udev_db_get_device ( udev_parent , dev_parent - > devpath ) = = 0 ) {
strlcat ( string , udev_parent - > name , maxsize ) ;
dbg ( " substitute parent node name'%s' " , udev_parent - > name ) ;
} else
dbg ( " parent not found in database " ) ;
udev_device_cleanup ( udev_parent ) ;
}
}
2005-02-10 11:03:55 +03:00
}
break ;
2005-06-20 02:29:38 +04:00
case SUBST_TEMP_NODE :
2007-04-30 23:48:30 +04:00
if ( udev - > tmp_node [ 0 ] = = ' \0 ' & & major ( udev - > devt ) > 0 ) {
2005-02-09 06:37:32 +03:00
dbg ( " create temporary device node for callout " ) ;
2005-03-07 06:29:43 +03:00
snprintf ( udev - > tmp_node , sizeof ( udev - > tmp_node ) , " %s/.tmp-%u-%u " ,
udev_root , major ( udev - > devt ) , minor ( udev - > devt ) ) ;
udev - > tmp_node [ sizeof ( udev - > tmp_node ) - 1 ] = ' \0 ' ;
2006-04-06 00:29:33 +04:00
udev_node_mknod ( udev , udev - > tmp_node , udev - > devt , 0600 , 0 , 0 ) ;
2005-02-09 06:37:32 +03:00
}
2005-03-07 06:29:43 +03:00
strlcat ( string , udev - > tmp_node , maxsize ) ;
2005-02-09 06:37:32 +03:00
dbg ( " substitute temporary device node name '%s' " , udev - > tmp_node ) ;
break ;
2005-06-20 02:29:38 +04:00
case SUBST_ROOT :
2005-03-07 06:29:43 +03:00
strlcat ( string , udev_root , maxsize ) ;
2005-02-10 11:03:55 +03:00
dbg ( " substitute udev_root '%s' " , udev_root ) ;
break ;
2007-06-03 00:06:01 +04:00
case SUBST_SYS :
strlcat ( string , sysfs_path , maxsize ) ;
dbg ( " substitute sysfs_path '%s' " , sysfs_path ) ;
break ;
2005-06-25 15:10:16 +04:00
case SUBST_ENV :
if ( attr = = NULL ) {
dbg ( " missing attribute " ) ;
break ;
}
pos = getenv ( attr ) ;
2005-07-12 16:46:36 +04:00
if ( pos = = NULL ) {
2005-09-14 16:28:59 +04:00
dbg ( " env '%s' not available " , attr ) ;
2005-06-25 15:10:16 +04:00
break ;
2005-07-12 16:46:36 +04:00
}
2005-06-25 15:10:16 +04:00
dbg ( " substitute env '%s=%s' " , attr , pos ) ;
2005-07-12 13:42:39 +04:00
strlcat ( string , pos , maxsize ) ;
2005-06-25 15:10:16 +04:00
break ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
default :
2005-06-20 02:29:38 +04:00
err ( " unknown substitution type=%i " , type ) ;
[PATCH] Adding '%s' format specifier to NAME and SYMLINK
On Thu, Feb 12, 2004 at 05:34:57PM -0800, Greg KH wrote:
> On Tue, Feb 10, 2004 at 09:14:20AM +0100, Hannes Reinecke wrote:
> > Hi all,
> >
> > this patch makes the format for NAME and SYMLINK a bit more flexible:
> > I've added a new format specifier '%s{<SYSFS_var>}', which allows for
> > the value of any sysfs entry found for this device to be inserted.
> > Example (for our S/390 fcp adapter):
> >
> > BUS="ccw", SYSFS_devtype="1732/03", NAME="%k" \
> > SYMLINK="zfcp-%s{hba_id}-%s{wwpn}:%s{fcp_lun}"
> >
> > I know this could also be done with an external program, but having this
> > incorporated into udev makes life easier, especially if run from
> > initramfs. Plus it makes the rules easier to follow, as the result is
> > directly visible and need not to be looked up in some external program.
> >
> > Comments etc. welcome.
>
> Oops, sorry I missed this for the 017 release. I'll look at it tomorrow
> and get back to you. At first glance it looks like a good thing.
>
> Oh, you forgot to update the documentation, that's important to do if
> you want this change to make it in :)
I took a part of the code and made a version that uses already implemented
attribute finding logic.
The parsing of the format length '%3x' and the '%x{attribute}' is a fuction now,
maybe there are more possible users in the future.
I've also added the test to udev-test.pl.
2004-02-17 08:36:34 +03:00
break ;
}
2005-06-20 02:29:38 +04:00
/* possibly truncate to format-char specified length */
2007-02-01 22:18:52 +03:00
if ( len > = 0 & & len < ( int ) strlen ( head ) ) {
2005-06-20 02:29:38 +04:00
head [ len ] = ' \0 ' ;
dbg ( " truncate to %i chars, subtitution string becomes '%s' " , len , head ) ;
}
strlcat ( string , temp , maxsize ) ;
2003-11-24 09:25:13 +03:00
}
}
2005-07-05 17:24:41 +04:00
static char * key_val ( struct udev_rule * rule , struct key * key )
{
return rule - > buf + key - > val_off ;
}
static char * key_pair_name ( struct udev_rule * rule , struct key_pair * pair )
{
return rule - > buf + pair - > key_name_off ;
}
static int match_key ( const char * key_name , struct udev_rule * rule , struct key * key , const char * val )
2005-07-04 21:44:25 +04:00
{
2005-07-12 14:52:56 +04:00
char value [ PATH_SIZE ] ;
2005-07-05 17:24:41 +04:00
char * key_value ;
2005-07-12 14:52:56 +04:00
char * pos ;
2007-03-31 04:46:32 +04:00
int match = 0 ;
2005-07-04 21:44:25 +04:00
2006-04-24 21:25:55 +04:00
if ( key - > operation ! = KEY_OP_MATCH & &
key - > operation ! = KEY_OP_NOMATCH )
2005-07-04 21:44:25 +04:00
return 0 ;
2007-03-31 04:46:32 +04:00
/* look for a matching string, parts are separated by '|' */
2005-07-12 14:52:56 +04:00
strlcpy ( value , rule - > buf + key - > val_off , sizeof ( value ) ) ;
key_value = value ;
dbg ( " key %s value='%s' " , key_name , key_value ) ;
while ( key_value ) {
pos = strchr ( key_value , ' | ' ) ;
if ( pos ) {
pos [ 0 ] = ' \0 ' ;
pos + + ;
}
2007-03-31 04:46:32 +04:00
2005-07-12 14:52:56 +04:00
dbg ( " match %s '%s' <-> '%s' " , key_name , key_value , val ) ;
2006-08-24 11:03:15 +04:00
match = ( fnmatch ( key_value , val , 0 ) = = 0 ) ;
2007-03-31 04:46:32 +04:00
if ( match )
break ;
2005-07-12 14:52:56 +04:00
key_value = pos ;
2005-07-04 21:44:25 +04:00
}
2007-03-31 04:46:32 +04:00
if ( match & & ( key - > operation = = KEY_OP_MATCH ) ) {
dbg ( " %s is true (matching value) " , key_name ) ;
return 0 ;
}
if ( ! match & & ( key - > operation = = KEY_OP_NOMATCH ) ) {
dbg ( " %s is true (non-matching value) " , key_name ) ;
return 0 ;
}
2005-07-04 21:44:25 +04:00
return - 1 ;
}
2005-08-29 05:48:17 +04:00
/* match a single rule against a given device and possibly its parent devices */
2006-01-09 23:18:00 +03:00
static int match_rule ( struct udevice * udev , struct udev_rule * rule )
2003-12-20 12:05:13 +03:00
{
2005-08-16 06:25:20 +04:00
int i ;
2005-03-28 04:12:39 +04:00
2005-07-05 17:24:41 +04:00
if ( match_key ( " ACTION " , rule , & rule - > action , udev - > action ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-04-02 19:45:35 +04:00
2006-08-19 18:06:25 +04:00
if ( match_key ( " KERNEL " , rule , & rule - > kernel , udev - > dev - > kernel ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2003-11-13 16:52:08 +03:00
2006-01-09 23:18:00 +03:00
if ( match_key ( " SUBSYSTEM " , rule , & rule - > subsystem , udev - > dev - > subsystem ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2004-11-12 08:52:55 +03:00
2006-01-09 23:18:00 +03:00
if ( match_key ( " DEVPATH " , rule , & rule - > devpath , udev - > dev - > devpath ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-06-20 02:29:38 +04:00
2006-08-19 18:06:25 +04:00
if ( match_key ( " DRIVER " , rule , & rule - > driver , udev - > dev - > driver ) )
goto nomatch ;
/* match NAME against a value assigned by an earlier rule */
2006-04-24 21:25:55 +04:00
if ( match_key ( " NAME " , rule , & rule - > name , udev - > name ) )
goto nomatch ;
2005-08-16 06:25:20 +04:00
for ( i = 0 ; i < rule - > env . count ; i + + ) {
struct key_pair * pair = & rule - > env . keys [ i ] ;
2005-03-13 13:40:32 +03:00
2005-08-16 06:25:20 +04:00
/* we only check for matches, assignments will be handled later */
2006-04-24 21:25:55 +04:00
if ( pair - > key . operation = = KEY_OP_MATCH | |
pair - > key . operation = = KEY_OP_NOMATCH ) {
2005-07-05 17:24:41 +04:00
const char * key_name = key_pair_name ( rule , pair ) ;
const char * value = getenv ( key_name ) ;
2005-03-13 13:40:32 +03:00
if ( ! value ) {
2005-08-16 06:25:20 +04:00
dbg ( " ENV{'%s'} is not set, treat as empty " , key_name ) ;
2005-07-16 07:50:34 +04:00
value = " " ;
2005-03-13 13:40:32 +03:00
}
2005-07-05 17:24:41 +04:00
if ( match_key ( " ENV " , rule , & pair - > key , value ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-03-13 13:40:32 +03:00
}
}
2007-06-03 02:01:46 +04:00
if ( rule - > test . operation ! = KEY_OP_UNSET ) {
char filename [ PATH_SIZE ] ;
2007-06-03 14:29:46 +04:00
char devpath [ PATH_SIZE ] ;
char * attr ;
2007-06-03 02:01:46 +04:00
struct stat statbuf ;
int match ;
strlcpy ( filename , key_val ( rule , & rule - > test ) , sizeof ( filename ) ) ;
udev_rules_apply_format ( udev , filename , sizeof ( filename ) ) ;
2007-06-03 14:29:46 +04:00
if ( attr_get_by_subsys_id ( filename , devpath , sizeof ( devpath ) , & attr ) ) {
strlcpy ( filename , sysfs_path , sizeof ( filename ) ) ;
strlcat ( filename , devpath , sizeof ( filename ) ) ;
if ( attr ! = NULL ) {
strlcat ( filename , " / " , sizeof ( filename ) ) ;
strlcat ( filename , attr , sizeof ( filename ) ) ;
}
}
2007-06-03 02:01:46 +04:00
match = ( stat ( filename , & statbuf ) = = 0 ) ;
info ( " '%s' %s " , filename , match ? " exists " : " does not exist " ) ;
if ( match & & rule - > test_mode_mask > 0 ) {
match = ( ( statbuf . st_mode & rule - > test_mode_mask ) > 0 ) ;
info ( " '%s' has mode=%#o and %s %#o " , filename , statbuf . st_mode ,
match ? " matches " : " does not match " ,
rule - > test_mode_mask ) ;
}
if ( match & & rule - > test . operation = = KEY_OP_NOMATCH )
goto nomatch ;
if ( ! match & & rule - > test . operation = = KEY_OP_MATCH )
goto nomatch ;
dbg ( " TEST key is true " ) ;
}
2005-07-07 22:05:51 +04:00
if ( rule - > wait_for_sysfs . operation ! = KEY_OP_UNSET ) {
2006-01-31 18:24:22 +03:00
int found ;
2005-07-07 22:05:51 +04:00
2006-01-31 18:24:22 +03:00
found = ( wait_for_sysfs ( udev , key_val ( rule , & rule - > wait_for_sysfs ) , 3 ) = = 0 ) ;
2006-08-20 20:16:27 +04:00
if ( ! found & & ( rule - > wait_for_sysfs . operation ! = KEY_OP_NOMATCH ) )
2006-01-31 18:24:22 +03:00
goto nomatch ;
2005-07-07 22:05:51 +04:00
}
2006-08-20 20:16:27 +04:00
/* check for matching sysfs attribute pairs */
for ( i = 0 ; i < rule - > attr . count ; i + + ) {
struct key_pair * pair = & rule - > attr . keys [ i ] ;
if ( pair - > key . operation = = KEY_OP_MATCH | |
pair - > key . operation = = KEY_OP_NOMATCH ) {
2006-08-19 18:06:25 +04:00
const char * key_name = key_pair_name ( rule , pair ) ;
const char * key_value = key_val ( rule , & pair - > key ) ;
2007-06-03 14:29:46 +04:00
char devpath [ PATH_SIZE ] ;
char * attrib ;
const char * value = NULL ;
2006-08-19 18:06:25 +04:00
char val [ VALUE_SIZE ] ;
size_t len ;
2007-06-03 14:29:46 +04:00
if ( attr_get_by_subsys_id ( key_name , devpath , sizeof ( devpath ) , & attrib ) ) {
if ( attrib ! = NULL )
value = sysfs_attr_get_value ( devpath , attrib ) ;
else
goto nomatch ;
}
if ( value = = NULL )
value = sysfs_attr_get_value ( udev - > dev - > devpath , key_name ) ;
2006-08-19 18:06:25 +04:00
if ( value = = NULL )
goto nomatch ;
strlcpy ( val , value , sizeof ( val ) ) ;
/* strip trailing whitespace of value, if not asked to match for it */
len = strlen ( key_value ) ;
if ( len > 0 & & ! isspace ( key_value [ len - 1 ] ) ) {
len = strlen ( val ) ;
while ( len > 0 & & isspace ( val [ len - 1 ] ) )
val [ - - len ] = ' \0 ' ;
dbg ( " removed %zi trailing whitespace chars from '%s' " , strlen ( val ) - len , val ) ;
}
if ( match_key ( " ATTR " , rule , & pair - > key , val ) )
goto nomatch ;
}
}
2006-01-16 08:12:49 +03:00
/* walk up the chain of parent devices and find a match */
udev - > dev_parent = udev - > dev ;
2005-02-11 20:33:40 +03:00
while ( 1 ) {
2006-08-19 18:06:25 +04:00
/* check for matching kernel device name */
if ( match_key ( " KERNELS " , rule , & rule - > kernels , udev - > dev_parent - > kernel ) )
2006-04-24 21:25:55 +04:00
goto try_parent ;
2004-11-13 07:21:12 +03:00
2006-08-19 18:06:25 +04:00
/* check for matching subsystem value */
if ( match_key ( " SUBSYSTEMS " , rule , & rule - > subsystems , udev - > dev_parent - > subsystem ) )
2006-04-24 21:25:55 +04:00
goto try_parent ;
2005-02-11 07:21:03 +03:00
2006-08-19 18:06:25 +04:00
/* check for matching driver */
if ( match_key ( " DRIVERS " , rule , & rule - > drivers , udev - > dev_parent - > driver ) )
2006-04-24 21:25:55 +04:00
goto try_parent ;
2003-11-13 16:52:08 +03:00
2006-09-05 04:18:06 +04:00
/* check for matching sysfs attribute pairs */
2006-08-20 20:16:27 +04:00
for ( i = 0 ; i < rule - > attrs . count ; i + + ) {
struct key_pair * pair = & rule - > attrs . keys [ i ] ;
if ( pair - > key . operation = = KEY_OP_MATCH | |
pair - > key . operation = = KEY_OP_NOMATCH ) {
2005-07-05 17:24:41 +04:00
const char * key_name = key_pair_name ( rule , pair ) ;
const char * key_value = key_val ( rule , & pair - > key ) ;
2006-01-09 23:18:00 +03:00
const char * value ;
char val [ VALUE_SIZE ] ;
2005-03-28 14:37:54 +04:00
size_t len ;
2005-03-13 13:40:32 +03:00
2006-01-16 08:12:49 +03:00
value = sysfs_attr_get_value ( udev - > dev_parent - > devpath , key_name ) ;
2006-01-29 19:08:44 +03:00
if ( value = = NULL )
value = sysfs_attr_get_value ( udev - > dev - > devpath , key_name ) ;
2006-01-09 23:18:00 +03:00
if ( value = = NULL )
2005-03-28 14:20:05 +04:00
goto try_parent ;
2006-01-09 23:18:00 +03:00
strlcpy ( val , value , sizeof ( val ) ) ;
2005-03-28 14:20:05 +04:00
/* strip trailing whitespace of value, if not asked to match for it */
2005-07-05 17:24:41 +04:00
len = strlen ( key_value ) ;
2006-01-09 23:18:00 +03:00
if ( len > 0 & & ! isspace ( key_value [ len - 1 ] ) ) {
len = strlen ( val ) ;
while ( len > 0 & & isspace ( val [ len - 1 ] ) )
val [ - - len ] = ' \0 ' ;
dbg ( " removed %zi trailing whitespace chars from '%s' " , strlen ( val ) - len , val ) ;
2005-03-28 14:20:05 +04:00
}
2006-08-19 18:06:25 +04:00
if ( match_key ( " ATTRS " , rule , & pair - > key , val ) )
2005-07-04 21:44:25 +04:00
goto try_parent ;
[PATCH] udev - drop all methods :)
> Hi,
> as promised yesterday, here is a patch that drops the explicit methods
> given in the udev config and implement only one type of rule.
>
> A rule now consists only of a number of keys to match. All known keys
> are valid in any combination. The former configs should work with a few
> changes:
>
> o the "<METHOD>, " at the beginning of the line should be removed
>
> o the result of the externel program is matched with RESULT= instead if ID=
> the PROGRAM= key is only valid if the program exits with zero
> (just exit with nozero in a script if the rule should not match)
>
> o rules are processed in order they appear in the file, no priority
>
> o if NAME="" is given, udev is instructed to ignore this device,
> no node will be created
>
>
> EXAMPLE:
>
> # combined BUS, SYSFS and KERNEL
> BUS="usb", KERNEL="video*", SYSFS_model="Creative Labs WebCam*", NAME="test/webcam%n"
>
> # exec script only for the first ide drive (hda), all other will be skipped
> BUS="ide", KERNEL="hda*", PROGRAM="/home/kay/src/udev.kay/extras/ide-devfs.sh %k %b %n", RESULT="hd*", NAME="%1c", SYMLINK="%2c %3c"
>
>
> The udev-test.pl and test.block works fine here.
> Please adapt your config and give it a try.
>
Here is a slightly better version of the patch.
After a conversation with Patrick, we are now able to execute the PROGRAM
and also match in all following rules with the RESULT value from this exec.
EXAMPLE:
We have 7 rules with RESULT and 2 with PROGRAM.
Only the 5th rule matches with the callout result from the exec in the 4th rule.
RULES:
PROGRAM="/bin/echo abc", RESULT="no_match", NAME="web-no-2"
KERNEL="video*", RESULT="123", NAME="web-no-3"
KERNEL="video*", RESULT="123", NAME="web-no-4"
PROGRAM="/bin/echo 123", RESULT="no_match", NAME="web-no-5"
KERNEL="video*", RESULT="123", NAME="web-yes"
RESULT:
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check PROGRAM
Jan 11 23:36:52 pim udev[26050]: execute_program: executing '/bin/echo abc'
Jan 11 23:36:52 pim udev[26050]: execute_program: result is 'abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: PROGRAM returned successful
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='no_match', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check PROGRAM
Jan 11 23:36:52 pim udev[26050]: execute_program: executing '/bin/echo 123'
Jan 11 23:36:52 pim udev[26050]: execute_program: result is '123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: PROGRAM returned successful
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='no_match', udev->program_result='123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: found matching rule, 'video*' becomes ''
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: name, 'web-yes' is going to have owner='', group='', mode = 0600
2004-01-13 08:39:05 +03:00
}
}
2006-01-09 23:18:00 +03:00
/* found matching device */
2005-02-14 03:46:05 +03:00
break ;
2004-02-12 09:28:51 +03:00
try_parent :
2006-01-16 08:12:49 +03:00
/* move to parent device */
2004-02-12 09:28:51 +03:00
dbg ( " try parent sysfs device " ) ;
2006-01-16 08:12:49 +03:00
udev - > dev_parent = sysfs_device_get_parent ( udev - > dev_parent ) ;
if ( udev - > dev_parent = = NULL )
goto nomatch ;
dbg ( " looking at dev_parent->devpath='%s' " , udev - > dev_parent - > devpath ) ;
2006-08-19 18:06:25 +04:00
dbg ( " looking at dev_parent->kernel='%s' " , udev - > dev_parent - > kernel ) ;
2004-01-23 11:21:13 +03:00
}
2005-02-11 07:21:03 +03:00
2005-02-14 03:46:05 +03:00
/* execute external program */
2005-07-05 17:24:41 +04:00
if ( rule - > program . operation ! = KEY_OP_UNSET ) {
2005-03-07 06:29:43 +03:00
char program [ PATH_SIZE ] ;
2005-06-25 17:35:14 +04:00
char result [ PATH_SIZE ] ;
2005-02-14 03:46:05 +03:00
2005-07-05 17:24:41 +04:00
strlcpy ( program , key_val ( rule , & rule - > program ) , sizeof ( program ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , program , sizeof ( program ) ) ;
2007-06-22 03:27:02 +04:00
if ( run_program ( program , udev - > dev - > subsystem , result , sizeof ( result ) ,
NULL , ( udev_log_priority > = LOG_INFO ) ) ! = 0 ) {
2005-07-12 14:52:56 +04:00
dbg ( " PROGRAM is false " ) ;
2005-08-11 19:32:59 +04:00
udev - > program_result [ 0 ] = ' \0 ' ;
2005-07-05 17:24:41 +04:00
if ( rule - > program . operation ! = KEY_OP_NOMATCH )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-03-13 07:46:31 +03:00
} else {
2005-08-28 17:55:58 +04:00
int count ;
2005-07-04 22:42:04 +04:00
dbg ( " PROGRAM matches " ) ;
2005-08-29 01:15:51 +04:00
remove_trailing_chars ( result , ' \n ' ) ;
2007-06-22 03:27:02 +04:00
if ( rule - > string_escape = = ESCAPE_UNSET | |
rule - > string_escape = = ESCAPE_REPLACE ) {
count = replace_chars ( result , ALLOWED_CHARS_INPUT ) ;
if ( count > 0 )
info ( " %i character(s) replaced " , count ) ;
}
2005-06-25 17:35:14 +04:00
dbg ( " result is '%s' " , result ) ;
strlcpy ( udev - > program_result , result , sizeof ( udev - > program_result ) ) ;
2005-07-04 22:42:04 +04:00
dbg ( " PROGRAM returned successful " ) ;
2005-07-05 17:24:41 +04:00
if ( rule - > program . operation = = KEY_OP_NOMATCH )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-02-14 03:46:05 +03:00
}
2005-07-04 22:42:04 +04:00
dbg ( " PROGRAM key is true " ) ;
2005-02-14 03:46:05 +03:00
}
/* check for matching result of external program */
2005-07-05 17:24:41 +04:00
if ( match_key ( " RESULT " , rule , & rule - > result , udev - > program_result ) )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-02-14 03:46:05 +03:00
2005-08-16 06:25:20 +04:00
/* import variables returned from program or or file into environment */
if ( rule - > import . operation ! = KEY_OP_UNSET ) {
char import [ PATH_SIZE ] ;
int rc = - 1 ;
strlcpy ( import , key_val ( rule , & rule - > import ) , sizeof ( import ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , import , sizeof ( import ) ) ;
2005-08-16 06:25:20 +04:00
dbg ( " check for IMPORT import='%s' " , import ) ;
if ( rule - > import_type = = IMPORT_PROGRAM ) {
rc = import_program_into_env ( udev , import ) ;
} else if ( rule - > import_type = = IMPORT_FILE ) {
dbg ( " import file import='%s' " , import ) ;
rc = import_file_into_env ( udev , import ) ;
2006-01-09 23:18:00 +03:00
} else if ( rule - > import_type = = IMPORT_PARENT ) {
2005-08-16 06:25:20 +04:00
dbg ( " import parent import='%s' " , import ) ;
2006-01-09 23:18:00 +03:00
rc = import_parent_into_env ( udev , import ) ;
2005-08-16 06:25:20 +04:00
}
2006-01-09 23:18:00 +03:00
if ( rc ! = 0 ) {
2005-08-16 06:25:20 +04:00
dbg ( " IMPORT failed " ) ;
if ( rule - > import . operation ! = KEY_OP_NOMATCH )
2006-01-16 08:12:49 +03:00
goto nomatch ;
2005-08-16 06:25:20 +04:00
} else
dbg ( " IMPORT '%s' imported " , key_val ( rule , & rule - > import ) ) ;
dbg ( " IMPORT key is true " ) ;
}
/* rule matches, if we have ENV assignments export it */
for ( i = 0 ; i < rule - > env . count ; i + + ) {
struct key_pair * pair = & rule - > env . keys [ i ] ;
if ( pair - > key . operation = = KEY_OP_ASSIGN ) {
2006-09-05 02:50:25 +04:00
char temp_value [ NAME_SIZE ] ;
2005-08-16 06:25:20 +04:00
const char * key_name = key_pair_name ( rule , pair ) ;
const char * value = key_val ( rule , & pair - > key ) ;
2006-09-05 02:50:25 +04:00
/* make sure we don't write to the same string we possibly read from */
strlcpy ( temp_value , value , sizeof ( temp_value ) ) ;
udev_rules_apply_format ( udev , temp_value , NAME_SIZE ) ;
2007-04-25 03:52:00 +04:00
if ( temp_value [ 0 ] = = ' \0 ' ) {
name_list_key_remove ( & udev - > env_list , key_name ) ;
unsetenv ( key_name ) ;
info ( " unset ENV '%s' " , key_name ) ;
} else {
2007-07-14 22:43:01 +04:00
struct name_entry * entry ;
2005-08-16 06:25:20 +04:00
2007-07-14 22:43:01 +04:00
entry = name_list_key_add ( & udev - > env_list , key_name , temp_value ) ;
if ( entry = = NULL )
2007-04-25 03:52:00 +04:00
break ;
2007-07-14 22:43:01 +04:00
putenv ( entry - > name ) ;
info ( " set ENV '%s' " , entry - > name ) ;
2007-04-25 03:52:00 +04:00
}
2005-08-16 06:25:20 +04:00
}
}
2007-05-16 21:51:13 +04:00
/* if we have ATTR assignments, write value to sysfs file */
2006-08-20 20:16:27 +04:00
for ( i = 0 ; i < rule - > attr . count ; i + + ) {
struct key_pair * pair = & rule - > attr . keys [ i ] ;
if ( pair - > key . operation = = KEY_OP_ASSIGN ) {
const char * key_name = key_pair_name ( rule , pair ) ;
2007-06-11 01:53:40 +04:00
char devpath [ PATH_SIZE ] ;
char * attrib ;
char attr [ PATH_SIZE ] = " " ;
2007-02-16 15:20:34 +03:00
char value [ NAME_SIZE ] ;
2006-08-20 20:16:27 +04:00
FILE * f ;
2007-06-11 01:53:40 +04:00
if ( attr_get_by_subsys_id ( key_name , devpath , sizeof ( devpath ) , & attrib ) ) {
if ( attrib ! = NULL ) {
strlcpy ( attr , sysfs_path , sizeof ( attr ) ) ;
strlcat ( attr , devpath , sizeof ( attr ) ) ;
strlcat ( attr , " / " , sizeof ( attr ) ) ;
strlcat ( attr , attrib , sizeof ( attr ) ) ;
}
}
if ( attr [ 0 ] = = ' \0 ' ) {
strlcpy ( attr , sysfs_path , sizeof ( attr ) ) ;
strlcat ( attr , udev - > dev - > devpath , sizeof ( attr ) ) ;
strlcat ( attr , " / " , sizeof ( attr ) ) ;
strlcat ( attr , key_name , sizeof ( attr ) ) ;
}
2007-02-16 15:20:34 +03:00
strlcpy ( value , key_val ( rule , & pair - > key ) , sizeof ( value ) ) ;
udev_rules_apply_format ( udev , value , sizeof ( value ) ) ;
info ( " writing '%s' to sysfs file '%s' " , value , attr ) ;
2006-08-20 20:16:27 +04:00
f = fopen ( attr , " w " ) ;
if ( f ! = NULL ) {
2007-03-23 19:18:03 +03:00
if ( ! udev - > test_run )
if ( fprintf ( f , " %s " , value ) < = 0 )
err ( " error writing ATTR{%s}: %s " , attr , strerror ( errno ) ) ;
2006-08-20 20:16:27 +04:00
fclose ( f ) ;
} else
err ( " error opening ATTR{%s} for writing: %s " , attr , strerror ( errno ) ) ;
}
}
2005-02-14 03:46:05 +03:00
return 0 ;
2006-01-16 08:12:49 +03:00
nomatch :
2005-02-11 07:21:03 +03:00
return - 1 ;
2004-01-23 11:21:13 +03:00
}
2006-01-09 23:18:00 +03:00
int udev_rules_get_name ( struct udev_rules * rules , struct udevice * udev )
2004-01-23 11:21:13 +03:00
{
2005-03-13 00:36:32 +03:00
struct udev_rule * rule ;
2005-07-08 00:32:48 +04:00
int name_set = 0 ;
2004-01-23 11:21:13 +03:00
2006-01-09 23:18:00 +03:00
dbg ( " udev->dev->devpath='%s' " , udev - > dev - > devpath ) ;
2006-08-19 18:06:25 +04:00
dbg ( " udev->dev->kernel='%s' " , udev - > dev - > kernel ) ;
2004-01-23 11:21:13 +03:00
/* look for a matching rule to apply */
2005-07-05 17:24:41 +04:00
udev_rules_iter_init ( rules ) ;
2005-06-24 20:05:32 +04:00
while ( 1 ) {
2005-07-05 17:24:41 +04:00
rule = udev_rules_iter_next ( rules ) ;
2005-06-24 20:05:32 +04:00
if ( rule = = NULL )
break ;
2006-04-24 21:25:55 +04:00
if ( name_set & &
( rule - > name . operation = = KEY_OP_ASSIGN | |
rule - > name . operation = = KEY_OP_ASSIGN_FINAL | |
rule - > name . operation = = KEY_OP_ADD ) ) {
2005-06-20 02:29:38 +04:00
dbg ( " node name already set, rule ignored " ) ;
continue ;
}
2004-01-23 11:21:13 +03:00
dbg ( " process rule " ) ;
2006-01-09 23:18:00 +03:00
if ( match_rule ( udev , rule ) = = 0 ) {
2005-02-14 08:03:06 +03:00
/* apply options */
2005-03-13 00:36:32 +03:00
if ( rule - > ignore_device ) {
2006-08-19 18:06:25 +04:00
info ( " rule applied, '%s' is ignored " , udev - > dev - > kernel ) ;
2005-04-02 19:45:35 +04:00
udev - > ignore_device = 1 ;
return 0 ;
2005-02-14 08:03:06 +03:00
}
2005-03-13 00:36:32 +03:00
if ( rule - > ignore_remove ) {
2005-03-04 22:52:19 +03:00
udev - > ignore_remove = 1 ;
2005-03-13 00:36:32 +03:00
dbg ( " remove event should be ignored " ) ;
2005-02-14 08:03:06 +03:00
}
2007-04-06 21:50:19 +04:00
if ( rule - > link_priority ! = 0 ) {
2007-03-16 17:16:08 +03:00
udev - > link_priority = rule - > link_priority ;
info ( " link_priority=%i " , udev - > link_priority ) ;
}
2005-02-14 08:03:06 +03:00
/* apply all_partitions option only at a main block device */
2006-01-09 23:18:00 +03:00
if ( rule - > partitions & &
strcmp ( udev - > dev - > subsystem , " block " ) = = 0 & & udev - > dev - > kernel_number [ 0 ] = = ' \0 ' ) {
2005-03-13 00:36:32 +03:00
udev - > partitions = rule - > partitions ;
2005-02-14 08:03:06 +03:00
dbg ( " creation of partition nodes requested " ) ;
}
2005-02-06 02:13:18 +03:00
/* apply permissions */
2005-06-05 06:57:03 +04:00
if ( ! udev - > mode_final & & rule - > mode ! = 0000 ) {
if ( rule - > mode_operation = = KEY_OP_ASSIGN_FINAL )
udev - > mode_final = 1 ;
2005-03-13 00:36:32 +03:00
udev - > mode = rule - > mode ;
2006-08-19 18:06:25 +04:00
dbg ( " applied mode=%#o to '%s' " , rule - > mode , udev - > dev - > kernel ) ;
2005-02-06 02:13:18 +03:00
}
2005-07-05 17:24:41 +04:00
if ( ! udev - > owner_final & & rule - > owner . operation ! = KEY_OP_UNSET ) {
if ( rule - > owner . operation = = KEY_OP_ASSIGN_FINAL )
2005-06-05 06:57:03 +04:00
udev - > owner_final = 1 ;
2005-07-05 17:24:41 +04:00
strlcpy ( udev - > owner , key_val ( rule , & rule - > owner ) , sizeof ( udev - > owner ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , udev - > owner , sizeof ( udev - > owner ) ) ;
2006-08-19 18:06:25 +04:00
dbg ( " applied owner='%s' to '%s' " , udev - > owner , udev - > dev - > kernel ) ;
2005-02-06 02:13:18 +03:00
}
2005-07-05 17:24:41 +04:00
if ( ! udev - > group_final & & rule - > group . operation ! = KEY_OP_UNSET ) {
if ( rule - > group . operation = = KEY_OP_ASSIGN_FINAL )
2005-06-05 06:57:03 +04:00
udev - > group_final = 1 ;
2005-07-05 17:24:41 +04:00
strlcpy ( udev - > group , key_val ( rule , & rule - > group ) , sizeof ( udev - > group ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , udev - > group , sizeof ( udev - > group ) ) ;
2006-08-19 18:06:25 +04:00
dbg ( " applied group='%s' to '%s' " , udev - > group , udev - > dev - > kernel ) ;
2005-02-06 02:13:18 +03:00
}
2005-02-21 16:48:12 +03:00
/* collect symlinks */
2005-07-05 17:24:41 +04:00
if ( ! udev - > symlink_final & & rule - > symlink . operation ! = KEY_OP_UNSET ) {
2005-03-07 06:29:43 +03:00
char temp [ PATH_SIZE ] ;
2005-03-05 07:35:31 +03:00
char * pos , * next ;
2005-08-28 17:55:58 +04:00
int count ;
2004-03-25 04:34:00 +03:00
2005-07-05 17:24:41 +04:00
if ( rule - > symlink . operation = = KEY_OP_ASSIGN_FINAL )
2005-06-05 06:57:03 +04:00
udev - > symlink_final = 1 ;
2005-07-05 17:24:41 +04:00
if ( rule - > symlink . operation = = KEY_OP_ASSIGN | | rule - > symlink . operation = = KEY_OP_ASSIGN_FINAL ) {
2005-06-05 17:55:29 +04:00
info ( " reset symlink list " ) ;
2005-08-27 18:15:41 +04:00
name_list_cleanup ( & udev - > symlink_list ) ;
2005-06-05 07:13:33 +04:00
}
2007-05-17 22:01:54 +04:00
/* allow multiple symlinks separated by spaces */
2005-07-05 17:24:41 +04:00
strlcpy ( temp , key_val ( rule , & rule - > symlink ) , sizeof ( temp ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , temp , sizeof ( temp ) ) ;
2007-06-22 03:27:02 +04:00
if ( rule - > string_escape = = ESCAPE_UNSET | |
rule - > string_escape = = ESCAPE_REPLACE ) {
count = replace_chars ( temp , ALLOWED_CHARS_FILE " " ) ;
if ( count > 0 )
info ( " %i character(s) replaced " , count ) ;
}
2005-08-28 17:55:58 +04:00
dbg ( " rule applied, added symlink(s) '%s' " , temp ) ;
2005-07-05 17:24:41 +04:00
pos = temp ;
2005-07-08 01:43:13 +04:00
while ( isspace ( pos [ 0 ] ) )
pos + + ;
next = strchr ( pos , ' ' ) ;
2005-07-05 17:24:41 +04:00
while ( next ) {
next [ 0 ] = ' \0 ' ;
2005-03-27 03:11:03 +04:00
info ( " add symlink '%s' " , pos ) ;
2005-03-05 07:35:31 +03:00
name_list_add ( & udev - > symlink_list , pos , 0 ) ;
2005-07-08 01:43:13 +04:00
while ( isspace ( next [ 1 ] ) )
next + + ;
2005-07-05 17:24:41 +04:00
pos = & next [ 1 ] ;
next = strchr ( pos , ' ' ) ;
2005-03-05 07:35:31 +03:00
}
2005-07-08 01:43:13 +04:00
if ( pos [ 0 ] ! = ' \0 ' ) {
info ( " add symlink '%s' " , pos ) ;
name_list_add ( & udev - > symlink_list , pos , 0 ) ;
}
2004-03-02 09:23:39 +03:00
}
2005-04-02 19:45:35 +04:00
/* set name, later rules with name set will be ignored */
2006-04-24 21:25:55 +04:00
if ( rule - > name . operation = = KEY_OP_ASSIGN | |
rule - > name . operation = = KEY_OP_ASSIGN_FINAL | |
rule - > name . operation = = KEY_OP_ADD ) {
2005-08-28 17:55:58 +04:00
int count ;
2006-01-27 03:40:26 +03:00
2005-07-08 00:32:48 +04:00
name_set = 1 ;
2005-07-05 17:24:41 +04:00
strlcpy ( udev - > name , key_val ( rule , & rule - > name ) , sizeof ( udev - > name ) ) ;
2006-01-25 03:28:31 +03:00
udev_rules_apply_format ( udev , udev - > name , sizeof ( udev - > name ) ) ;
2007-06-22 03:27:02 +04:00
if ( rule - > string_escape = = ESCAPE_UNSET | |
rule - > string_escape = = ESCAPE_REPLACE ) {
count = replace_chars ( udev - > name , ALLOWED_CHARS_FILE ) ;
if ( count > 0 )
info ( " %i character(s) replaced " , count ) ;
}
2005-07-05 17:24:41 +04:00
2006-08-19 18:06:25 +04:00
info ( " rule applied, '%s' becomes '%s' " , udev - > dev - > kernel , udev - > name ) ;
2006-01-09 23:18:00 +03:00
if ( strcmp ( udev - > dev - > subsystem , " net " ) ! = 0 )
2005-07-05 17:24:41 +04:00
dbg ( " name, '%s' is going to have owner='%s', group='%s', mode=%#o partitions=%i " ,
udev - > name , udev - > owner , udev - > group , udev - > mode , udev - > partitions ) ;
2005-04-02 19:45:35 +04:00
}
2004-11-29 15:44:01 +03:00
2005-07-05 17:24:41 +04:00
if ( ! udev - > run_final & & rule - > run . operation ! = KEY_OP_UNSET ) {
2007-07-14 22:43:01 +04:00
struct name_entry * entry ;
2005-07-05 17:24:41 +04:00
if ( rule - > run . operation = = KEY_OP_ASSIGN_FINAL )
2005-06-05 06:57:03 +04:00
udev - > run_final = 1 ;
2005-07-05 17:24:41 +04:00
if ( rule - > run . operation = = KEY_OP_ASSIGN | | rule - > run . operation = = KEY_OP_ASSIGN_FINAL ) {
2005-06-05 17:55:29 +04:00
info ( " reset run list " ) ;
2005-08-27 18:15:41 +04:00
name_list_cleanup ( & udev - > run_list ) ;
2005-06-05 07:13:33 +04:00
}
2006-01-27 03:40:26 +03:00
dbg ( " add run '%s' " , key_val ( rule , & rule - > run ) ) ;
2007-07-14 22:43:01 +04:00
entry = name_list_add ( & udev - > run_list , key_val ( rule , & rule - > run ) , 0 ) ;
if ( rule - > run_ignore_error )
entry - > ignore_error = 1 ;
2004-03-02 09:23:39 +03:00
}
2005-03-13 00:55:08 +03:00
if ( rule - > last_rule ) {
dbg ( " last rule to be applied " ) ;
break ;
}
2005-07-16 09:46:31 +04:00
if ( rule - > goto_label . operation ! = KEY_OP_UNSET ) {
dbg ( " moving forward to label '%s' " , key_val ( rule , & rule - > goto_label ) ) ;
udev_rules_iter_label ( rules , key_val ( rule , & rule - > goto_label ) ) ;
}
2004-01-23 11:21:13 +03:00
}
[PATCH] udev - drop all methods :)
> Hi,
> as promised yesterday, here is a patch that drops the explicit methods
> given in the udev config and implement only one type of rule.
>
> A rule now consists only of a number of keys to match. All known keys
> are valid in any combination. The former configs should work with a few
> changes:
>
> o the "<METHOD>, " at the beginning of the line should be removed
>
> o the result of the externel program is matched with RESULT= instead if ID=
> the PROGRAM= key is only valid if the program exits with zero
> (just exit with nozero in a script if the rule should not match)
>
> o rules are processed in order they appear in the file, no priority
>
> o if NAME="" is given, udev is instructed to ignore this device,
> no node will be created
>
>
> EXAMPLE:
>
> # combined BUS, SYSFS and KERNEL
> BUS="usb", KERNEL="video*", SYSFS_model="Creative Labs WebCam*", NAME="test/webcam%n"
>
> # exec script only for the first ide drive (hda), all other will be skipped
> BUS="ide", KERNEL="hda*", PROGRAM="/home/kay/src/udev.kay/extras/ide-devfs.sh %k %b %n", RESULT="hd*", NAME="%1c", SYMLINK="%2c %3c"
>
>
> The udev-test.pl and test.block works fine here.
> Please adapt your config and give it a try.
>
Here is a slightly better version of the patch.
After a conversation with Patrick, we are now able to execute the PROGRAM
and also match in all following rules with the RESULT value from this exec.
EXAMPLE:
We have 7 rules with RESULT and 2 with PROGRAM.
Only the 5th rule matches with the callout result from the exec in the 4th rule.
RULES:
PROGRAM="/bin/echo abc", RESULT="no_match", NAME="web-no-2"
KERNEL="video*", RESULT="123", NAME="web-no-3"
KERNEL="video*", RESULT="123", NAME="web-no-4"
PROGRAM="/bin/echo 123", RESULT="no_match", NAME="web-no-5"
KERNEL="video*", RESULT="123", NAME="web-yes"
RESULT:
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check PROGRAM
Jan 11 23:36:52 pim udev[26050]: execute_program: executing '/bin/echo abc'
Jan 11 23:36:52 pim udev[26050]: execute_program: result is 'abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: PROGRAM returned successful
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='no_match', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='abc'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check PROGRAM
Jan 11 23:36:52 pim udev[26050]: execute_program: executing '/bin/echo 123'
Jan 11 23:36:52 pim udev[26050]: execute_program: result is '123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: PROGRAM returned successful
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='no_match', udev->program_result='123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT is not matching
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: process rule
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for KERNEL dev->kernel='video*' class_dev->name='video0'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: KERNEL matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: check for RESULT dev->result='123', udev->program_result='123'
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: RESULT matches
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: found matching rule, 'video*' becomes ''
Jan 11 23:36:52 pim udev[26050]: namedev_name_device: name, 'web-yes' is going to have owner='', group='', mode = 0600
2004-01-13 08:39:05 +03:00
}
2003-10-20 08:56:21 +04:00
2005-07-08 00:32:48 +04:00
if ( ! name_set ) {
2006-08-19 18:06:25 +04:00
strlcpy ( udev - > name , udev - > dev - > kernel , sizeof ( udev - > name ) ) ;
2005-08-11 23:01:46 +04:00
info ( " no node name set, will use kernel name '%s' " , udev - > name ) ;
2005-03-04 22:52:19 +03:00
}
2003-11-13 04:38:14 +03:00
2005-02-09 06:37:32 +03:00
if ( udev - > tmp_node [ 0 ] ! = ' \0 ' ) {
dbg ( " removing temporary device node " ) ;
unlink_secure ( udev - > tmp_node ) ;
udev - > tmp_node [ 0 ] = ' \0 ' ;
}
2003-11-12 19:26:08 +03:00
return 0 ;
2003-07-19 09:48:28 +04:00
}
2005-04-02 19:45:35 +04:00
2006-01-09 23:18:00 +03:00
int udev_rules_get_run ( struct udev_rules * rules , struct udevice * udev )
2005-04-02 19:45:35 +04:00
{
struct udev_rule * rule ;
2006-08-19 18:06:25 +04:00
dbg ( " udev->kernel='%s' " , udev - > dev - > kernel ) ;
2005-07-20 20:12:56 +04:00
2005-04-02 19:45:35 +04:00
/* look for a matching rule to apply */
2005-07-05 17:24:41 +04:00
udev_rules_iter_init ( rules ) ;
2005-06-24 20:05:32 +04:00
while ( 1 ) {
2005-07-05 17:24:41 +04:00
rule = udev_rules_iter_next ( rules ) ;
2005-06-24 20:05:32 +04:00
if ( rule = = NULL )
break ;
2005-04-02 19:45:35 +04:00
2005-06-24 20:05:32 +04:00
dbg ( " process rule " ) ;
2005-07-05 17:24:41 +04:00
if ( rule - > name . operation ! = KEY_OP_UNSET | | rule - > symlink . operation ! = KEY_OP_UNSET | |
2007-06-03 02:01:46 +04:00
rule - > mode_operation ! = KEY_OP_UNSET | | rule - > owner . operation ! = KEY_OP_UNSET | |
rule - > group . operation ! = KEY_OP_UNSET ) {
2005-04-02 19:45:35 +04:00
dbg ( " skip rule that names a device " ) ;
continue ;
}
2006-01-09 23:18:00 +03:00
if ( match_rule ( udev , rule ) = = 0 ) {
2005-06-05 17:55:29 +04:00
if ( rule - > ignore_device ) {
2006-08-19 18:06:25 +04:00
info ( " rule applied, '%s' is ignored " , udev - > dev - > kernel ) ;
2005-06-05 17:55:29 +04:00
udev - > ignore_device = 1 ;
return 0 ;
2005-04-02 19:45:35 +04:00
}
2005-07-05 17:24:41 +04:00
if ( ! udev - > run_final & & rule - > run . operation ! = KEY_OP_UNSET ) {
2007-07-14 22:43:01 +04:00
struct name_entry * entry ;
2007-06-03 02:01:46 +04:00
if ( rule - > run . operation = = KEY_OP_ASSIGN | |
rule - > run . operation = = KEY_OP_ASSIGN_FINAL ) {
2005-06-05 17:55:29 +04:00
info ( " reset run list " ) ;
2005-08-27 18:15:41 +04:00
name_list_cleanup ( & udev - > run_list ) ;
2005-04-02 19:45:35 +04:00
}
2006-01-27 03:40:26 +03:00
dbg ( " add run '%s' " , key_val ( rule , & rule - > run ) ) ;
2007-07-14 22:43:01 +04:00
entry = name_list_add ( & udev - > run_list , key_val ( rule , & rule - > run ) , 0 ) ;
if ( rule - > run_ignore_error )
entry - > ignore_error = 1 ;
2005-07-05 17:24:41 +04:00
if ( rule - > run . operation = = KEY_OP_ASSIGN_FINAL )
2005-06-05 17:55:29 +04:00
break ;
2005-04-02 19:45:35 +04:00
}
2005-06-05 17:55:29 +04:00
if ( rule - > last_rule ) {
dbg ( " last rule to be applied " ) ;
break ;
}
2005-07-20 20:12:56 +04:00
if ( rule - > goto_label . operation ! = KEY_OP_UNSET ) {
dbg ( " moving forward to label '%s' " , key_val ( rule , & rule - > goto_label ) ) ;
udev_rules_iter_label ( rules , key_val ( rule , & rule - > goto_label ) ) ;
}
2005-04-02 19:45:35 +04:00
}
}
return 0 ;
}