2005-04-27 07:59:47 +04:00
/*
* udev . c
*
* Userspace devfs
*
* Copyright ( C ) 2003 Greg Kroah - Hartman < greg @ kroah . com >
*
*
* 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 .
*
* 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 .
*
* 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 . ,
* 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*
*/
# include <stdlib.h>
# include <string.h>
2003-04-10 21:53:46 +04:00
# include <stdio.h>
# include <fcntl.h>
# include <unistd.h>
# include <errno.h>
2005-04-27 07:59:47 +04:00
# include "udev.h"
# include "udev_version.h"
2003-07-17 12:24:51 +04:00
# include "namedev.h"
2003-07-19 16:06:55 +04:00
# include "libsysfs/libsysfs.h"
2005-04-27 07:59:47 +04:00
2003-07-19 16:06:55 +04:00
static char sysfs_path [ SYSFS_PATH_MAX ] ;
2005-04-27 07:59:47 +04:00
static char * get_action ( void )
{
char * action ;
action = getenv ( " ACTION " ) ;
return action ;
}
static char * get_device ( void )
{
2003-07-19 16:06:55 +04:00
char * device ;
2005-04-27 07:59:47 +04:00
2003-07-19 16:06:55 +04:00
device = getenv ( " DEVPATH " ) ;
2005-04-27 07:59:47 +04:00
return device ;
}
2003-04-10 21:53:46 +04:00
/*
* Right now the major / minor of a device is stored in a file called
* " dev " in sysfs .
* The number is stored as :
* MMmm
* MM is the major
* mm is the minor
* The value is in hex .
* Yes , this will probably change when we go to a bigger major / minor
* range , and will have to be changed at that time .
*/
2003-07-19 16:06:55 +04:00
static int get_major_minor ( struct sysfs_class_device * class_dev , int * major , int * minor )
2003-04-10 21:53:46 +04:00
{
char temp [ 3 ] ;
int retval = 0 ;
2003-07-19 16:06:55 +04:00
char * dev ;
dev = sysfs_get_value_from_attributes ( class_dev - > directory - > attributes , " dev " ) ;
if ( dev = = NULL )
2003-04-10 21:53:46 +04:00
return - ENODEV ;
2003-07-19 16:06:55 +04:00
dbg ( " dev = %s " , dev ) ;
2003-04-10 21:53:46 +04:00
2003-07-19 16:06:55 +04:00
temp [ 0 ] = dev [ 0 ] ;
temp [ 1 ] = dev [ 1 ] ;
2003-04-10 21:53:46 +04:00
temp [ 2 ] = 0x00 ;
* major = ( int ) strtol ( & temp [ 0 ] , NULL , 16 ) ;
2003-07-19 16:06:55 +04:00
temp [ 0 ] = dev [ 2 ] ;
temp [ 1 ] = dev [ 3 ] ;
2003-04-10 21:53:46 +04:00
temp [ 2 ] = 0x00 ;
* minor = ( int ) strtol ( & temp [ 0 ] , NULL , 16 ) ;
dbg ( " found major = %d, minor = %d " , * major , * minor ) ;
retval = 0 ;
return retval ;
}
/*
* Here would go a call to the naming deamon , to get the name we want to have
* for this device . But for now , let ' s just default to whatever the kernel is
* calling the device as that will keep the " old-style " naming policy
*/
static char * get_name ( char * dev , int major , int minor )
{
static char name [ 100 ] ;
char * temp ;
temp = strrchr ( dev , ' / ' ) ;
if ( temp = = NULL )
return NULL ;
strncpy ( name , & temp [ 1 ] , sizeof ( name ) ) ;
dbg ( " name is %s " , name ) ;
return & name [ 0 ] ;
}
/*
* We also want to add some permissions here , and possibly some symlinks
*/
static int create_node ( char * name , char type , int major , int minor , int mode )
{
char * argv [ 7 ] ;
char mode_string [ 100 ] ;
char type_string [ 3 ] ;
char major_string [ 20 ] ;
char minor_string [ 20 ] ;
char filename [ 255 ] ;
int retval = 0 ;
strncpy ( filename , UDEV_ROOT , sizeof ( filename ) ) ;
strncat ( filename , name , sizeof ( filename ) ) ;
snprintf ( mode_string , sizeof ( mode_string ) , " --mode=%#o " , mode ) ;
snprintf ( type_string , sizeof ( type_string ) , " %c " , type ) ;
snprintf ( major_string , sizeof ( major_string ) , " %d " , major ) ;
snprintf ( minor_string , sizeof ( minor_string ) , " %d " , minor ) ;
argv [ 0 ] = MKNOD ;
argv [ 1 ] = mode_string ;
argv [ 2 ] = filename ;
argv [ 3 ] = type_string ;
argv [ 4 ] = major_string ;
argv [ 5 ] = minor_string ;
argv [ 6 ] = NULL ;
dbg ( " executing %s %s %s %s %s %s " ,
argv [ 0 ] , argv [ 1 ] , argv [ 2 ] , argv [ 3 ] , argv [ 4 ] , argv [ 5 ] ) ;
switch ( fork ( ) ) {
case 0 :
/* we are the child, so lets run the program */
execv ( MKNOD , argv ) ;
exit ( 0 ) ;
break ;
case ( - 1 ) :
dbg ( " fork failed. " ) ;
retval = - EFAULT ;
break ;
default :
break ;
}
return retval ;
}
2003-04-10 22:16:34 +04:00
/*
* We also want to clean up any symlinks that were created in create_node ( )
*/
static int delete_node ( char * name )
{
char filename [ 255 ] ;
strncpy ( filename , UDEV_ROOT , sizeof ( filename ) ) ;
strncat ( filename , name , sizeof ( filename ) ) ;
dbg ( " unlinking %s " , filename ) ;
return unlink ( filename ) ;
}
2003-07-19 16:06:55 +04:00
struct sysfs_class_device * get_class_dev ( char * device_name )
2003-04-10 21:53:46 +04:00
{
2003-07-19 16:06:55 +04:00
char dev_path [ SYSFS_PATH_MAX ] ;
struct sysfs_class_device * class_dev ;
strcpy ( dev_path , sysfs_path ) ;
strcat ( dev_path , device_name ) ;
dbg ( " looking at %s " , dev_path ) ;
/* open up the sysfs class device for this thing... */
class_dev = sysfs_open_class_device ( dev_path ) ;
if ( class_dev = = NULL ) {
dbg ( " sysfs_open_class_device failed " ) ;
return NULL ;
}
dbg ( " class_dev->name = %s " , class_dev - > name ) ;
return class_dev ;
}
static int add_device ( char * device , char * subsystem )
{
struct sysfs_class_device * class_dev ;
struct device_attr attr ;
//char *name;
2003-04-10 22:02:32 +04:00
int major ;
int minor ;
2003-07-19 16:06:55 +04:00
char type ;
//int mode;
2003-04-10 22:02:32 +04:00
int retval = - EINVAL ;
2003-07-19 16:06:55 +04:00
/* for now, the block layer is the only place where block devices are */
if ( strcmp ( subsystem , " block " ) = = 0 )
type = ' b ' ;
else
type = ' c ' ;
class_dev = get_class_dev ( device ) ;
if ( class_dev = = NULL )
goto exit ;
retval = namedev_name_device ( class_dev , & attr ) ;
if ( retval )
return retval ;
retval = get_major_minor ( class_dev , & major , & minor ) ;
2003-04-10 22:02:32 +04:00
if ( retval ) {
dbg ( " get_major_minor failed " ) ;
goto exit ;
}
2003-04-10 21:53:46 +04:00
2003-07-19 16:06:55 +04:00
sysfs_close_class_device ( class_dev ) ;
2003-04-10 21:53:46 +04:00
2003-07-19 16:06:55 +04:00
return create_node ( attr . name , type , major , minor , attr . mode ) ;
2003-04-10 22:02:32 +04:00
exit :
return retval ;
}
2003-04-10 22:16:34 +04:00
static int remove_device ( char * device )
2003-04-10 22:02:32 +04:00
{
2003-04-10 22:16:34 +04:00
char * name ;
int retval = 0 ;
name = get_name ( device , 0 , 0 ) ;
if ( name = = NULL ) {
dbg ( " get_name failed " ) ;
retval = - ENODEV ;
goto exit ;
}
return delete_node ( name ) ;
exit :
return retval ;
2003-04-10 21:53:46 +04:00
}
2003-07-19 16:06:55 +04:00
static int udev_init ( void )
{
int retval ;
retval = sysfs_get_mnt_path ( sysfs_path , SYSFS_PATH_MAX ) ;
dbg ( " sysfs_path = %s " , sysfs_path ) ;
return retval ;
}
2005-04-27 07:59:47 +04:00
int main ( int argc , char * argv [ ] )
{
char * action ;
2003-04-10 21:53:46 +04:00
char * device ;
int retval = - EINVAL ;
2005-04-27 07:59:47 +04:00
if ( argc ! = 2 ) {
dbg ( " unknown number of arguments " ) ;
2003-04-10 21:53:46 +04:00
goto exit ;
2005-04-27 07:59:47 +04:00
}
2003-07-19 16:06:55 +04:00
device = get_device ( ) ;
if ( ! device ) {
dbg ( " no device? " ) ;
goto exit ;
}
dbg ( " looking at %s " , device ) ;
2003-07-17 12:24:51 +04:00
2003-07-19 16:06:55 +04:00
/* we only care about class devices and block stuff */
if ( ! strstr ( device , " class " ) & &
! strstr ( device , " block " ) ) {
dbg ( " not block or class " ) ;
goto exit ;
}
2003-07-17 07:18:06 +04:00
/* sleep for a second or two to give the kernel a chance to
* create the dev file
*/
2003-07-19 16:06:55 +04:00
sleep ( 1 ) ;
2003-07-17 07:18:06 +04:00
2003-07-19 16:06:55 +04:00
udev_init ( ) ;
namedev_init ( ) ;
2005-04-27 07:59:47 +04:00
action = get_action ( ) ;
if ( ! action ) {
dbg ( " no action? " ) ;
2003-04-10 21:53:46 +04:00
goto exit ;
2005-04-27 07:59:47 +04:00
}
2003-04-10 22:02:32 +04:00
if ( strcmp ( action , " add " ) = = 0 )
2003-07-19 16:06:55 +04:00
return add_device ( device , argv [ 1 ] ) ;
2003-04-10 21:53:46 +04:00
2003-04-10 22:02:32 +04:00
if ( strcmp ( action , " remove " ) = = 0 )
2003-04-10 22:16:34 +04:00
return remove_device ( device ) ;
2003-04-10 21:53:46 +04:00
2003-04-10 22:02:32 +04:00
dbg ( " Unknown action: %s " , action ) ;
return - EINVAL ;
2003-04-10 21:53:46 +04:00
retval = 0 ;
exit :
return retval ;
2005-04-27 07:59:47 +04:00
}