2001-12-05 19:41:52 +03:00
/*
2004-03-30 23:08:57 +04:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
2012-01-09 16:26:14 +04:00
* Copyright ( C ) 2004 - 2012 Red Hat , Inc . All rights reserved .
2001-12-05 19:41:52 +03:00
*
2004-03-30 23:08:57 +04:00
* This file is part of the device - mapper userspace tools .
*
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v .2 .1 .
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2001-12-05 19:41:52 +03:00
*/
2008-11-03 21:59:59 +03:00
# include "dmlib.h"
2002-11-14 17:44:42 +03:00
# include "libdm-targets.h"
# include "libdm-common.h"
2004-07-01 19:14:29 +04:00
# include "kdev_t.h"
2008-11-01 05:19:19 +03:00
# include "dm-ioctl.h"
2001-12-05 19:41:52 +03:00
# include <stdarg.h>
# include <sys/param.h>
2007-12-03 20:56:36 +03:00
# include <sys/ioctl.h>
2007-11-30 19:42:26 +03:00
# include <fcntl.h>
2009-09-25 22:08:04 +04:00
# include <dirent.h>
2005-01-27 19:16:54 +03:00
2009-07-31 19:53:11 +04:00
# ifdef UDEV_SYNC_SUPPORT
# include <sys / types.h>
# include <sys / ipc.h>
# include <sys / sem.h>
2009-09-11 19:56:06 +04:00
# include <libudev.h>
# endif
2009-07-31 19:53:11 +04:00
2007-11-30 19:42:26 +03:00
# ifdef linux
# include <linux / fs.h>
# endif
2004-04-06 22:54:00 +04:00
# ifdef HAVE_SELINUX
# include <selinux / selinux.h>
# endif
2010-12-13 13:43:56 +03:00
# ifdef HAVE_SELINUX_LABEL_H
# include <selinux / label.h>
# endif
2004-04-06 22:54:00 +04:00
2012-02-15 16:23:15 +04:00
# define DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME "DM_DEFAULT_NAME_MANGLING_MODE"
2001-12-05 19:41:52 +03:00
# define DEV_DIR " / dev / "
2010-05-27 19:02:56 +04:00
# ifdef UDEV_SYNC_SUPPORT
# ifdef _SEM_SEMUN_UNDEFINED
union semun
{
int val ; /* value for SETVAL */
struct semid_ds * buf ; /* buffer for IPC_STAT & IPC_SET */
unsigned short int * array ; /* array for GETALL & SETALL */
struct seminfo * __buf ; /* buffer for IPC_INFO */
} ;
# endif
# endif
2001-12-05 19:41:52 +03:00
static char _dm_dir [ PATH_MAX ] = DEV_DIR DM_DIR ;
2011-09-22 21:17:07 +04:00
static char _sysfs_dir [ PATH_MAX ] = " /sys/ " ;
2012-01-09 16:26:14 +04:00
static char _path0 [ PATH_MAX ] ; /* path buffer, safe 4kB on stack */
2001-12-05 19:41:52 +03:00
2012-01-10 06:03:31 +04:00
# define DM_MAX_UUID_PREFIX_LEN 15
static char _default_uuid_prefix [ DM_MAX_UUID_PREFIX_LEN + 1 ] = " LVM- " ;
2003-01-22 00:25:11 +03:00
static int _verbose = 0 ;
2011-06-13 07:32:45 +04:00
static int _suspended_dev_counter = 0 ;
2012-02-28 18:24:57 +04:00
static dm_string_mangling_t _name_mangling_mode = DEFAULT_DM_NAME_MANGLING ;
2003-01-22 00:25:11 +03:00
2010-12-13 13:43:56 +03:00
# ifdef HAVE_SELINUX_LABEL_H
static struct selabel_handle * _selabel_handle = NULL ;
# endif
2009-07-31 19:53:11 +04:00
# ifdef UDEV_SYNC_SUPPORT
2010-08-03 11:56:03 +04:00
static int _semaphore_supported = - 1 ;
2009-09-11 19:56:06 +04:00
static int _udev_running = - 1 ;
2009-07-31 19:53:11 +04:00
static int _sync_with_udev = 1 ;
2010-01-11 18:36:24 +03:00
static int _udev_checking = 1 ;
2009-07-31 19:53:11 +04:00
# endif
2012-02-15 16:23:15 +04:00
void dm_lib_init ( void )
{
const char * env ;
env = getenv ( DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME ) ;
if ( env & & * env ) {
if ( ! strcasecmp ( env , " none " ) )
_name_mangling_mode = DM_STRING_MANGLING_NONE ;
else if ( ! strcasecmp ( env , " auto " ) )
_name_mangling_mode = DM_STRING_MANGLING_AUTO ;
else if ( ! strcasecmp ( env , " hex " ) )
_name_mangling_mode = DM_STRING_MANGLING_HEX ;
} else
_name_mangling_mode = DEFAULT_DM_NAME_MANGLING ;
}
2002-01-03 13:39:21 +03:00
/*
2001-12-05 19:41:52 +03:00
* Library users can provide their own logging
* function .
*/
2009-07-10 13:59:37 +04:00
2011-03-30 01:53:46 +04:00
__attribute__ ( ( format ( printf , 5 , 0 ) ) )
2009-07-10 13:59:37 +04:00
static void _default_log_line ( int level ,
2010-07-09 19:34:40 +04:00
const char * file __attribute__ ( ( unused ) ) ,
int line __attribute__ ( ( unused ) ) , int dm_errno ,
2009-07-10 13:59:37 +04:00
const char * f , va_list ap )
2001-12-05 19:41:52 +03:00
{
2007-06-28 21:27:02 +04:00
int use_stderr = level & _LOG_STDERR ;
level & = ~ _LOG_STDERR ;
2001-12-05 19:41:52 +03:00
2003-01-22 00:25:11 +03:00
if ( level > _LOG_WARN & & ! _verbose )
2002-03-14 16:39:33 +03:00
return ;
2003-01-22 00:25:11 +03:00
if ( level < _LOG_WARN )
2002-03-19 02:39:42 +03:00
vfprintf ( stderr , f , ap ) ;
2003-01-22 00:25:11 +03:00
else
2007-06-28 21:27:02 +04:00
vfprintf ( use_stderr ? stderr : stdout , f , ap ) ;
2002-03-14 16:39:33 +03:00
2003-01-22 00:25:11 +03:00
if ( level < _LOG_WARN )
fprintf ( stderr , " \n " ) ;
else
2007-06-28 21:27:02 +04:00
fprintf ( use_stderr ? stderr : stdout , " \n " ) ;
2001-12-05 19:41:52 +03:00
}
2011-03-30 01:53:46 +04:00
__attribute__ ( ( format ( printf , 5 , 6 ) ) )
2009-07-10 13:59:37 +04:00
static void _default_log_with_errno ( int level ,
2010-07-09 19:34:40 +04:00
const char * file __attribute__ ( ( unused ) ) ,
int line __attribute__ ( ( unused ) ) , int dm_errno ,
2009-07-10 13:59:37 +04:00
const char * f , . . . )
{
va_list ap ;
va_start ( ap , f ) ;
_default_log_line ( level , file , line , dm_errno , f , ap ) ;
va_end ( ap ) ;
}
2011-03-30 01:53:46 +04:00
__attribute__ ( ( format ( printf , 4 , 5 ) ) )
2009-07-10 13:59:37 +04:00
static void _default_log ( int level , const char * file ,
int line , const char * f , . . . )
{
va_list ap ;
va_start ( ap , f ) ;
_default_log_line ( level , file , line , 0 , f , ap ) ;
va_end ( ap ) ;
}
2006-01-31 17:50:38 +03:00
dm_log_fn dm_log = _default_log ;
2009-07-10 13:59:37 +04:00
dm_log_with_errno_fn dm_log_with_errno = _default_log_with_errno ;
2001-12-05 19:41:52 +03:00
void dm_log_init ( dm_log_fn fn )
{
2003-12-21 19:08:20 +03:00
if ( fn )
2006-01-31 17:50:38 +03:00
dm_log = fn ;
2003-12-21 19:08:20 +03:00
else
2006-01-31 17:50:38 +03:00
dm_log = _default_log ;
2009-07-10 13:59:37 +04:00
dm_log_with_errno = _default_log_with_errno ;
}
int dm_log_is_non_default ( void )
{
return ( dm_log = = _default_log ) ? 0 : 1 ;
}
void dm_log_with_errno_init ( dm_log_with_errno_fn fn )
{
if ( fn )
dm_log_with_errno = fn ;
else
dm_log_with_errno = _default_log_with_errno ;
dm_log = _default_log ;
2001-12-05 19:41:52 +03:00
}
2003-01-22 00:25:11 +03:00
void dm_log_init_verbose ( int level )
{
_verbose = level ;
}
2002-11-14 22:26:28 +03:00
static void _build_dev_path ( char * buffer , size_t len , const char * dev_name )
2001-12-14 16:30:04 +03:00
{
/* If there's a /, assume caller knows what they're doing */
if ( strchr ( dev_name , ' / ' ) )
snprintf ( buffer , len , " %s " , dev_name ) ;
else
2002-03-19 02:39:42 +03:00
snprintf ( buffer , len , " %s/%s " , _dm_dir , dev_name ) ;
2001-12-14 16:30:04 +03:00
}
2002-01-17 17:13:25 +03:00
int dm_get_library_version ( char * version , size_t size )
{
strncpy ( version , DM_LIB_VERSION , size ) ;
return 1 ;
}
2011-06-13 07:32:45 +04:00
void inc_suspended ( void )
{
_suspended_dev_counter + + ;
log_debug ( " Suspended device counter increased to %d " , _suspended_dev_counter ) ;
}
void dec_suspended ( void )
{
if ( ! _suspended_dev_counter ) {
log_error ( " Attempted to decrement suspended device counter below zero. " ) ;
return ;
}
_suspended_dev_counter - - ;
log_debug ( " Suspended device counter reduced to %d " , _suspended_dev_counter ) ;
}
int dm_get_suspended_counter ( void )
{
return _suspended_dev_counter ;
}
2012-02-15 15:27:01 +04:00
int dm_set_name_mangling_mode ( dm_string_mangling_t name_mangling_mode )
{
_name_mangling_mode = name_mangling_mode ;
return 1 ;
}
dm_string_mangling_t dm_get_name_mangling_mode ( void )
{
return _name_mangling_mode ;
}
2001-12-05 19:41:52 +03:00
struct dm_task * dm_task_create ( int type )
{
2010-10-01 01:06:50 +04:00
struct dm_task * dmt = dm_zalloc ( sizeof ( * dmt ) ) ;
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
if ( ! dmt ) {
2006-01-31 17:50:38 +03:00
log_error ( " dm_task_create: malloc(% " PRIsize_t " ) failed " ,
sizeof ( * dmt ) ) ;
2002-03-19 02:39:42 +03:00
return NULL ;
}
2001-12-05 19:41:52 +03:00
2006-05-10 20:23:41 +04:00
if ( ! dm_check_version ( ) ) {
dm_free ( dmt ) ;
2011-03-18 16:21:02 +03:00
return_NULL ;
2006-05-10 20:23:41 +04:00
}
2005-01-06 21:22:44 +03:00
2002-03-19 02:39:42 +03:00
dmt - > type = type ;
2002-01-11 15:12:46 +03:00
dmt - > minor = - 1 ;
2003-04-02 23:03:00 +04:00
dmt - > major = - 1 ;
2009-06-18 00:55:24 +04:00
dmt - > allow_default_major_fallback = 1 ;
2008-06-07 00:44:35 +04:00
dmt - > uid = DM_DEVICE_UID ;
dmt - > gid = DM_DEVICE_GID ;
dmt - > mode = DM_DEVICE_MODE ;
2005-09-20 20:39:12 +04:00
dmt - > no_open_count = 0 ;
2007-11-27 23:57:05 +03:00
dmt - > read_ahead = DM_READ_AHEAD_AUTO ;
dmt - > read_ahead_flags = 0 ;
2009-10-26 17:29:33 +03:00
dmt - > event_nr = 0 ;
2009-08-03 22:01:45 +04:00
dmt - > cookie_set = 0 ;
2009-11-06 03:43:08 +03:00
dmt - > query_inactive_table = 0 ;
2010-10-15 05:10:27 +04:00
dmt - > new_uuid = 0 ;
2011-02-04 19:08:11 +03:00
dmt - > secure_data = 0 ;
2003-01-22 00:25:11 +03:00
2002-03-19 02:39:42 +03:00
return dmt ;
2001-12-05 19:41:52 +03:00
}
2009-09-25 22:08:04 +04:00
/*
* Find the name associated with a given device number by scanning _dm_dir .
*/
2012-02-15 15:27:01 +04:00
static int _find_dm_name_of_device ( dev_t st_rdev , char * buf , size_t buf_len )
2009-09-25 22:08:04 +04:00
{
const char * name ;
char path [ PATH_MAX ] ;
struct dirent * dirent ;
DIR * d ;
2012-02-15 15:27:01 +04:00
struct stat st ;
int r = 0 ;
2009-09-25 22:08:04 +04:00
if ( ! ( d = opendir ( _dm_dir ) ) ) {
log_sys_error ( " opendir " , _dm_dir ) ;
2012-02-15 15:27:01 +04:00
return 0 ;
2009-09-25 22:08:04 +04:00
}
while ( ( dirent = readdir ( d ) ) ) {
name = dirent - > d_name ;
if ( ! strcmp ( name , " . " ) | | ! strcmp ( name , " .. " ) )
continue ;
if ( dm_snprintf ( path , sizeof ( path ) , " %s/%s " , _dm_dir ,
name ) = = - 1 ) {
log_error ( " Couldn't create path for %s " , name ) ;
continue ;
}
2012-02-15 15:27:01 +04:00
if ( stat ( path , & st ) )
2009-09-25 22:08:04 +04:00
continue ;
2012-02-15 15:27:01 +04:00
if ( st . st_rdev = = st_rdev ) {
strncpy ( buf , name , buf_len ) ;
r = 1 ;
2009-09-25 22:08:04 +04:00
break ;
}
}
if ( closedir ( d ) )
log_sys_error ( " closedir " , _dm_dir ) ;
2012-02-15 15:27:01 +04:00
return r ;
2009-09-25 22:08:04 +04:00
}
2012-02-15 15:27:01 +04:00
static int _is_whitelisted_char ( char c )
2001-12-05 19:41:52 +03:00
{
2009-09-25 22:08:04 +04:00
/*
2012-02-15 15:27:01 +04:00
* Actually , DM supports any character in a device name .
* This whitelist is just for proper integration with udev .
2001-12-14 16:30:04 +03:00
*/
2012-02-15 15:27:01 +04:00
if ( ( c > = ' 0 ' & & c < = ' 9 ' ) | |
( c > = ' A ' & & c < = ' Z ' ) | |
( c > = ' a ' & & c < = ' z ' ) | |
strchr ( " #+-.:=@_ " , c ) ! = NULL )
return 1 ;
2009-01-07 15:17:40 +03:00
2012-02-15 15:27:01 +04:00
return 0 ;
}
2009-09-25 22:08:04 +04:00
2012-10-10 18:59:11 +04:00
int check_multiple_mangled_string_allowed ( const char * str , const char * str_name ,
dm_string_mangling_t mode )
2012-03-05 16:48:12 +04:00
{
2012-10-10 18:59:11 +04:00
if ( mode = = DM_STRING_MANGLING_AUTO & & strstr ( str , " \\ x5cx " ) ) {
log_error ( " The %s \" %s \" seems to be mangled more than once. "
" This is not allowed in auto mode. " , str_name , str ) ;
2012-03-05 16:48:12 +04:00
return 0 ;
}
return 1 ;
}
2012-02-15 15:27:01 +04:00
/*
* Mangle all characters in the input string which are not on a whitelist
* with ' \ xNN ' format where NN is the hex value of the character .
*/
2012-10-10 18:59:11 +04:00
int mangle_string ( const char * str , const char * str_name , size_t len ,
char * buf , size_t buf_len , dm_string_mangling_t mode )
2012-02-15 15:27:01 +04:00
{
int need_mangling = - 1 ; /* -1 don't know yet, 0 no, 1 yes */
size_t i , j ;
if ( ! str | | ! buf )
return - 1 ;
/* Is there anything to do at all? */
2012-03-05 16:40:34 +04:00
if ( ! * str | | ! len )
2012-02-15 15:27:01 +04:00
return 0 ;
if ( buf_len < DM_NAME_LEN ) {
2012-10-10 18:59:11 +04:00
log_error ( INTERNAL_ERROR " mangle_string: supplied buffer too small " ) ;
2012-02-15 15:27:01 +04:00
return - 1 ;
}
2012-03-05 16:40:34 +04:00
if ( mode = = DM_STRING_MANGLING_NONE )
mode = DM_STRING_MANGLING_AUTO ;
2012-02-15 15:27:01 +04:00
for ( i = 0 , j = 0 ; str [ i ] ; i + + ) {
if ( mode = = DM_STRING_MANGLING_AUTO ) {
/*
* Detect already mangled part of the string and keep it .
* Return error on mixture of mangled / not mangled !
*/
if ( str [ i ] = = ' \\ ' & & str [ i + 1 ] = = ' x ' ) {
if ( ( len - i < 4 ) | | ( need_mangling = = 1 ) )
goto bad1 ;
if ( buf_len - j < 4 )
goto bad2 ;
memcpy ( & buf [ j ] , & str [ i ] , 4 ) ;
i + = 3 ; j + = 4 ;
need_mangling = 0 ;
continue ;
}
2009-09-25 23:06:05 +04:00
}
2001-12-14 16:30:04 +03:00
2012-02-15 15:27:01 +04:00
if ( _is_whitelisted_char ( str [ i ] ) ) {
/* whitelisted, keep it. */
if ( buf_len - j < 1 )
goto bad2 ;
buf [ j ] = str [ i ] ;
j + + ;
} else {
/*
* Not on a whitelist , mangle it .
* Return error on mixture of mangled / not mangled
* unless a DM_STRING_MANGLING_HEX is used ! .
*/
if ( ( mode ! = DM_STRING_MANGLING_HEX ) & & ( need_mangling = = 0 ) )
goto bad1 ;
if ( buf_len - j < 4 )
goto bad2 ;
sprintf ( & buf [ j ] , " \\ x%02x " , ( unsigned char ) str [ i ] ) ;
j + = 4 ;
need_mangling = 1 ;
2001-12-14 16:30:04 +03:00
}
}
2012-02-15 15:27:01 +04:00
if ( buf_len - j < 1 )
goto bad2 ;
buf [ j ] = ' \0 ' ;
/* All chars in the string whitelisted? */
if ( need_mangling = = - 1 )
need_mangling = 0 ;
return need_mangling ;
bad1 :
2012-10-10 18:59:11 +04:00
log_error ( " The %s \" %s \" contains mixed mangled and unmangled "
" characters or it's already mangled improperly. " , str_name , str ) ;
2012-02-15 15:27:01 +04:00
return - 1 ;
bad2 :
2012-10-10 18:59:11 +04:00
log_error ( " Mangled form of the %s too long for \" %s \" . " , str_name , str ) ;
2012-02-15 15:27:01 +04:00
return - 1 ;
}
2012-02-15 15:39:38 +04:00
/*
* Try to unmangle supplied string .
* Return value : - 1 on error , 0 when no unmangling needed , 1 when unmangling applied
*/
2012-10-10 18:59:11 +04:00
int unmangle_string ( const char * str , const char * str_name , size_t len ,
char * buf , size_t buf_len , dm_string_mangling_t mode )
2012-02-15 15:39:38 +04:00
{
2012-03-05 16:43:03 +04:00
int strict = mode ! = DM_STRING_MANGLING_NONE ;
2012-02-15 15:39:38 +04:00
char str_rest [ DM_NAME_LEN ] ;
size_t i , j ;
int code ;
int r = 0 ;
if ( ! str | | ! buf )
return - 1 ;
/* Is there anything to do at all? */
2012-03-05 16:40:34 +04:00
if ( ! * str | | ! len )
2012-02-15 15:39:38 +04:00
return 0 ;
if ( buf_len < DM_NAME_LEN ) {
2012-10-10 18:59:11 +04:00
log_error ( INTERNAL_ERROR " unmangle_string: supplied buffer too small " ) ;
2012-02-15 15:39:38 +04:00
return - 1 ;
}
for ( i = 0 , j = 0 ; str [ i ] ; i + + , j + + ) {
2012-03-05 16:43:03 +04:00
if ( strict & & ! ( _is_whitelisted_char ( str [ i ] ) | | str [ i ] = = ' \\ ' ) ) {
2012-10-10 18:59:11 +04:00
log_error ( " The %s \" %s \" should be mangled but "
" it contains blacklisted characters. " , str_name , str ) ;
2012-03-05 16:43:03 +04:00
j = 0 ; r = - 1 ;
goto out ;
}
2012-02-15 15:39:38 +04:00
if ( str [ i ] = = ' \\ ' & & str [ i + 1 ] = = ' x ' ) {
if ( ! sscanf ( & str [ i + 2 ] , " %2x%s " , & code , str_rest ) ) {
2012-10-10 18:59:11 +04:00
log_debug ( " Hex encoding mismatch detected in %s \" %s \" "
" while trying to unmangle it. " , str_name , str ) ;
2012-02-15 15:39:38 +04:00
goto out ;
}
buf [ j ] = ( unsigned char ) code ;
/* skip the encoded part we've just decoded! */
i + = 3 ;
/* unmangling applied */
r = 1 ;
} else
buf [ j ] = str [ i ] ;
}
out :
buf [ j ] = ' \0 ' ;
return r ;
}
2012-02-15 15:27:01 +04:00
static int _dm_task_set_name ( struct dm_task * dmt , const char * name ,
dm_string_mangling_t mangling_mode )
{
char mangled_name [ DM_NAME_LEN ] ;
2012-03-05 16:40:34 +04:00
int r = 0 ;
2012-02-15 15:27:01 +04:00
dm_free ( dmt - > dev_name ) ;
dmt - > dev_name = NULL ;
dm_free ( dmt - > mangled_dev_name ) ;
dmt - > mangled_dev_name = NULL ;
2009-01-07 15:17:40 +03:00
if ( strlen ( name ) > = DM_NAME_LEN ) {
2012-02-15 15:27:01 +04:00
log_error ( " Name \" %s \" too long. " , name ) ;
2009-01-07 15:17:40 +03:00
return 0 ;
}
2012-10-10 18:59:11 +04:00
if ( ! check_multiple_mangled_string_allowed ( name , " name " , mangling_mode ) )
2012-03-05 16:48:12 +04:00
return_0 ;
2012-03-05 16:40:34 +04:00
if ( mangling_mode ! = DM_STRING_MANGLING_NONE & &
2012-10-10 18:59:11 +04:00
( r = mangle_string ( name , " name " , strlen ( name ) , mangled_name ,
sizeof ( mangled_name ) , mangling_mode ) ) < 0 ) {
2012-02-15 15:27:01 +04:00
log_error ( " Failed to mangle device name \" %s \" . " , name ) ;
return 0 ;
}
/* Store mangled_dev_name only if it differs from dev_name! */
if ( r ) {
log_debug ( " Device name mangled [%s]: %s --> %s " ,
mangling_mode = = DM_STRING_MANGLING_AUTO ? " auto " : " hex " ,
name , mangled_name ) ;
if ( ! ( dmt - > mangled_dev_name = dm_strdup ( mangled_name ) ) ) {
log_error ( " _dm_task_set_name: dm_strdup(%s) failed " , mangled_name ) ;
return 0 ;
}
}
if ( ! ( dmt - > dev_name = dm_strdup ( name ) ) ) {
log_error ( " _dm_task_set_name: strdup(%s) failed " , name ) ;
2001-12-14 16:30:04 +03:00
return 0 ;
}
2002-03-19 02:39:42 +03:00
return 1 ;
2001-12-05 19:41:52 +03:00
}
2012-02-15 15:27:01 +04:00
static int _dm_task_set_name_from_path ( struct dm_task * dmt , const char * path ,
const char * name )
{
char buf [ PATH_MAX ] ;
struct stat st1 , st2 ;
const char * final_name ;
if ( dmt - > type = = DM_DEVICE_CREATE ) {
log_error ( " Name \" %s \" invalid. It contains \" / \" . " , path ) ;
return 0 ;
}
if ( stat ( path , & st1 ) ) {
log_error ( " Device %s not found " , path ) ;
return 0 ;
}
/*
* If supplied path points to same device as last component
* under / dev / mapper , use that name directly . Otherwise call
* _find_dm_name_of_device ( ) to scan _dm_dir for a match .
*/
if ( dm_snprintf ( buf , sizeof ( buf ) , " %s/%s " , _dm_dir , name ) = = - 1 ) {
log_error ( " Couldn't create path for %s " , name ) ;
return 0 ;
}
2012-02-28 12:36:51 +04:00
if ( ! stat ( buf , & st2 ) & & ( st1 . st_rdev = = st2 . st_rdev ) )
2012-02-15 15:27:01 +04:00
final_name = name ;
else if ( _find_dm_name_of_device ( st1 . st_rdev , buf , sizeof ( buf ) ) )
final_name = buf ;
else {
log_error ( " Device %s not found " , name ) ;
return 0 ;
}
/* This is an already existing path - do not mangle! */
return _dm_task_set_name ( dmt , final_name , DM_STRING_MANGLING_NONE ) ;
}
int dm_task_set_name ( struct dm_task * dmt , const char * name )
{
char * pos ;
/* Path supplied for existing device? */
if ( ( pos = strrchr ( name , ' / ' ) ) )
return _dm_task_set_name_from_path ( dmt , name , pos + 1 ) ;
return _dm_task_set_name ( dmt , name , dm_get_name_mangling_mode ( ) ) ;
}
const char * dm_task_get_name ( const struct dm_task * dmt )
{
return ( dmt - > dmi . v4 - > name ) ;
}
2012-10-10 18:59:47 +04:00
static char * _task_get_string_mangled ( const char * str , const char * str_name ,
char * buf , size_t buf_size ,
dm_string_mangling_t mode )
{
char * rs ;
int r ;
if ( ( r = mangle_string ( str , str_name , strlen ( str ) , buf , buf_size , mode ) ) < 0 )
return NULL ;
if ( ! ( rs = r ? dm_strdup ( buf ) : dm_strdup ( str ) ) )
log_error ( " _task_get_string_mangled: dm_strdup failed " ) ;
return rs ;
}
static char * _task_get_string_unmangled ( const char * str , const char * str_name ,
char * buf , size_t buf_size ,
dm_string_mangling_t mode )
{
char * rs ;
int r = 0 ;
/*
* Unless the mode used is ' none ' , the string
* is * already * unmangled on ioctl return !
*/
if ( mode = = DM_STRING_MANGLING_NONE & &
( r = unmangle_string ( str , str_name , strlen ( str ) , buf , buf_size , mode ) ) < 0 )
return NULL ;
if ( ! ( rs = r ? dm_strdup ( buf ) : dm_strdup ( str ) ) )
log_error ( " _task_get_string_unmangled: dm_strdup failed " ) ;
return rs ;
}
2012-02-15 15:39:38 +04:00
char * dm_task_get_name_mangled ( const struct dm_task * dmt )
{
const char * s = dm_task_get_name ( dmt ) ;
char buf [ DM_NAME_LEN ] ;
2012-10-10 18:59:47 +04:00
char * rs ;
2012-02-15 15:39:38 +04:00
2012-10-10 18:59:47 +04:00
if ( ! ( rs = _task_get_string_mangled ( s , " name " , buf , sizeof ( buf ) , dm_get_name_mangling_mode ( ) ) ) )
2012-02-15 15:39:38 +04:00
log_error ( " Failed to mangle device name \" %s \" . " , s ) ;
return rs ;
}
char * dm_task_get_name_unmangled ( const struct dm_task * dmt )
{
const char * s = dm_task_get_name ( dmt ) ;
char buf [ DM_NAME_LEN ] ;
2012-10-10 18:59:47 +04:00
char * rs ;
2012-02-15 15:39:38 +04:00
2012-10-10 18:59:47 +04:00
if ( ! ( rs = _task_get_string_unmangled ( s , " name " , buf , sizeof ( buf ) , dm_get_name_mangling_mode ( ) ) ) )
2012-02-15 15:39:38 +04:00
log_error ( " Failed to unmangle device name \" %s \" . " , s ) ;
2012-10-10 18:59:47 +04:00
return rs ;
}
const char * dm_task_get_uuid ( const struct dm_task * dmt )
{
return ( dmt - > dmi . v4 - > uuid ) ;
}
char * dm_task_get_uuid_mangled ( const struct dm_task * dmt )
{
const char * s = dm_task_get_uuid ( dmt ) ;
char buf [ DM_UUID_LEN ] ;
char * rs ;
if ( ! ( rs = _task_get_string_mangled ( s , " UUID " , buf , sizeof ( buf ) , dm_get_name_mangling_mode ( ) ) ) )
log_error ( " Failed to mangle device uuid \" %s \" . " , s ) ;
return rs ;
}
char * dm_task_get_uuid_unmangled ( const struct dm_task * dmt )
{
const char * s = dm_task_get_uuid ( dmt ) ;
char buf [ DM_UUID_LEN ] ;
char * rs ;
if ( ! ( rs = _task_get_string_unmangled ( s , " UUID " , buf , sizeof ( buf ) , dm_get_name_mangling_mode ( ) ) ) )
log_error ( " Failed to unmangle device uuid \" %s \" . " , s ) ;
2012-02-15 15:39:38 +04:00
return rs ;
}
2012-01-17 18:36:58 +04:00
int dm_task_set_newname ( struct dm_task * dmt , const char * newname )
{
2012-02-15 15:27:01 +04:00
dm_string_mangling_t mangling_mode = dm_get_name_mangling_mode ( ) ;
char mangled_name [ DM_NAME_LEN ] ;
2012-03-05 16:40:34 +04:00
int r = 0 ;
2012-02-15 15:27:01 +04:00
2012-01-17 18:36:58 +04:00
if ( strchr ( newname , ' / ' ) ) {
log_error ( " Name \" %s \" invalid. It contains \" / \" . " , newname ) ;
return 0 ;
}
if ( strlen ( newname ) > = DM_NAME_LEN ) {
log_error ( " Name \" %s \" too long " , newname ) ;
return 0 ;
}
2012-10-10 18:59:11 +04:00
if ( ! check_multiple_mangled_string_allowed ( newname , " new name " , mangling_mode ) )
2012-03-05 16:48:12 +04:00
return_0 ;
2012-03-05 16:40:34 +04:00
if ( mangling_mode ! = DM_STRING_MANGLING_NONE & &
2012-10-10 18:59:11 +04:00
( r = mangle_string ( newname , " new name " , strlen ( newname ) , mangled_name ,
sizeof ( mangled_name ) , mangling_mode ) ) < 0 ) {
2012-02-15 15:27:01 +04:00
log_error ( " Failed to mangle new device name \" %s \" " , newname ) ;
return 0 ;
}
if ( r ) {
log_debug ( " New device name mangled [%s]: %s --> %s " ,
mangling_mode = = DM_STRING_MANGLING_AUTO ? " auto " : " hex " ,
newname , mangled_name ) ;
newname = mangled_name ;
}
2012-01-17 18:36:58 +04:00
if ( ! ( dmt - > newname = dm_strdup ( newname ) ) ) {
log_error ( " dm_task_set_newname: strdup(%s) failed " , newname ) ;
return 0 ;
}
2012-02-15 15:27:01 +04:00
2012-01-17 18:36:58 +04:00
dmt - > new_uuid = 0 ;
return 1 ;
}
2002-03-12 01:44:36 +03:00
int dm_task_set_uuid ( struct dm_task * dmt , const char * uuid )
{
2012-10-10 19:00:41 +04:00
char mangled_uuid [ DM_UUID_LEN ] ;
dm_string_mangling_t mangling_mode = dm_get_name_mangling_mode ( ) ;
int r = 0 ;
2010-11-29 13:11:50 +03:00
dm_free ( dmt - > uuid ) ;
2012-10-10 19:00:41 +04:00
dmt - > uuid = NULL ;
dm_free ( dmt - > mangled_uuid ) ;
dmt - > mangled_uuid = NULL ;
if ( ! check_multiple_mangled_string_allowed ( uuid , " UUID " , mangling_mode ) )
return_0 ;
if ( mangling_mode ! = DM_STRING_MANGLING_NONE & &
( r = mangle_string ( uuid , " UUID " , strlen ( uuid ) , mangled_uuid ,
sizeof ( mangled_uuid ) , mangling_mode ) ) < 0 ) {
log_error ( " Failed to mangle device uuid \" %s \" . " , uuid ) ;
return 0 ;
}
if ( r ) {
log_debug ( " Device uuid mangled [%s]: %s --> %s " ,
mangling_mode = = DM_STRING_MANGLING_AUTO ? " auto " : " hex " ,
uuid , mangled_uuid ) ;
if ( ! ( dmt - > mangled_uuid = dm_strdup ( mangled_uuid ) ) ) {
log_error ( " dm_task_set_uuid: dm_strdup(%s) failed " , mangled_uuid ) ;
return 0 ;
}
}
2002-03-12 01:44:36 +03:00
2005-10-17 02:57:20 +04:00
if ( ! ( dmt - > uuid = dm_strdup ( uuid ) ) ) {
2002-03-12 01:44:36 +03:00
log_error ( " dm_task_set_uuid: strdup(%s) failed " , uuid ) ;
return 0 ;
}
return 1 ;
}
2003-04-02 23:03:00 +04:00
int dm_task_set_major ( struct dm_task * dmt , int major )
{
dmt - > major = major ;
2009-06-18 00:55:24 +04:00
dmt - > allow_default_major_fallback = 0 ;
2003-04-02 23:03:00 +04:00
return 1 ;
}
2002-01-11 15:12:46 +03:00
int dm_task_set_minor ( struct dm_task * dmt , int minor )
{
2002-03-19 02:39:42 +03:00
dmt - > minor = minor ;
2002-01-11 15:12:46 +03:00
2002-03-19 02:39:42 +03:00
return 1 ;
}
2002-01-11 15:12:46 +03:00
2009-06-18 00:55:24 +04:00
int dm_task_set_major_minor ( struct dm_task * dmt , int major , int minor ,
int allow_default_major_fallback )
{
dmt - > major = major ;
dmt - > minor = minor ;
dmt - > allow_default_major_fallback = allow_default_major_fallback ;
return 1 ;
}
2006-02-03 17:23:22 +03:00
int dm_task_set_uid ( struct dm_task * dmt , uid_t uid )
{
dmt - > uid = uid ;
return 1 ;
}
int dm_task_set_gid ( struct dm_task * dmt , gid_t gid )
{
dmt - > gid = gid ;
return 1 ;
}
int dm_task_set_mode ( struct dm_task * dmt , mode_t mode )
{
dmt - > mode = mode ;
return 1 ;
}
2011-07-01 18:09:19 +04:00
int dm_task_enable_checks ( struct dm_task * dmt )
{
dmt - > enable_checks = 1 ;
return 1 ;
}
2002-03-19 02:39:42 +03:00
int dm_task_add_target ( struct dm_task * dmt , uint64_t start , uint64_t size ,
const char * ttype , const char * params )
2001-12-05 19:41:52 +03:00
{
2002-03-19 02:39:42 +03:00
struct target * t = create_target ( start , size , ttype , params ) ;
if ( ! t )
2011-11-18 23:34:02 +04:00
return_0 ;
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
if ( ! dmt - > head )
dmt - > head = dmt - > tail = t ;
else {
dmt - > tail - > next = t ;
dmt - > tail = t ;
}
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
return 1 ;
2001-12-05 19:41:52 +03:00
}
2010-12-13 15:44:09 +03:00
# ifdef HAVE_SELINUX
2010-12-13 13:43:56 +03:00
static int _selabel_lookup ( const char * path , mode_t mode ,
security_context_t * scontext )
{
# ifdef HAVE_SELINUX_LABEL_H
if ( ! _selabel_handle & &
! ( _selabel_handle = selabel_open ( SELABEL_CTX_FILE , NULL , 0 ) ) ) {
log_error ( " selabel_open failed: %s " , strerror ( errno ) ) ;
return 0 ;
}
if ( selabel_lookup ( _selabel_handle , scontext , path , mode ) ) {
2011-03-03 16:05:40 +03:00
log_debug ( " selabel_lookup failed for %s: %s " ,
path , strerror ( errno ) ) ;
2010-12-13 13:43:56 +03:00
return 0 ;
}
2010-12-13 15:30:04 +03:00
# else
2010-12-13 13:43:56 +03:00
if ( matchpathcon ( path , mode , scontext ) ) {
2011-03-03 16:05:40 +03:00
log_debug ( " matchpathcon failed for %s: %s " ,
path , strerror ( errno ) ) ;
2010-12-13 13:43:56 +03:00
return 0 ;
}
# endif
return 1 ;
}
2010-12-13 15:44:09 +03:00
# endif
2010-12-13 13:43:56 +03:00
int dm_prepare_selinux_context ( const char * path , mode_t mode )
2004-04-06 22:54:00 +04:00
{
2009-10-12 08:06:42 +04:00
# ifdef HAVE_SELINUX
2010-12-13 13:43:56 +03:00
security_context_t scontext = NULL ;
2004-04-06 22:54:00 +04:00
if ( is_selinux_enabled ( ) < = 0 )
2004-07-03 22:14:12 +04:00
return 1 ;
2004-04-06 22:54:00 +04:00
2010-12-13 13:43:56 +03:00
if ( path ) {
if ( ! _selabel_lookup ( path , mode , & scontext ) )
return_0 ;
log_debug ( " Preparing SELinux context for %s to %s. " , path , scontext ) ;
}
else
log_debug ( " Resetting SELinux context to default value. " ) ;
if ( setfscreatecon ( scontext ) < 0 ) {
log_sys_error ( " setfscreatecon " , path ) ;
freecon ( scontext ) ;
2004-04-06 22:54:00 +04:00
return 0 ;
}
2010-12-13 13:43:56 +03:00
freecon ( scontext ) ;
# endif
return 1 ;
}
int dm_set_selinux_context ( const char * path , mode_t mode )
{
# ifdef HAVE_SELINUX
security_context_t scontext ;
if ( is_selinux_enabled ( ) < = 0 )
return 1 ;
if ( ! _selabel_lookup ( path , mode , & scontext ) )
return_0 ;
2005-06-13 17:11:48 +04:00
log_debug ( " Setting SELinux context for %s to %s. " , path , scontext ) ;
2005-06-11 01:30:21 +04:00
2004-04-16 16:24:46 +04:00
if ( ( lsetfilecon ( path , scontext ) < 0 ) & & ( errno ! = ENOTSUP ) ) {
2007-07-28 14:23:02 +04:00
log_sys_error ( " lsetfilecon " , path ) ;
2005-06-13 17:11:48 +04:00
freecon ( scontext ) ;
2004-04-06 22:54:00 +04:00
return 0 ;
}
2005-06-13 17:11:48 +04:00
freecon ( scontext ) ;
2009-10-12 08:06:42 +04:00
# endif
2004-04-06 22:54:00 +04:00
return 1 ;
}
2010-12-13 13:43:56 +03:00
void selinux_release ( void )
{
# ifdef HAVE_SELINUX_LABEL_H
if ( _selabel_handle )
selabel_close ( _selabel_handle ) ;
_selabel_handle = NULL ;
# endif
}
2011-06-28 01:43:58 +04:00
static int _warn_if_op_needed ( int warn_if_udev_failed )
{
return warn_if_udev_failed & & dm_udev_get_sync_support ( ) & & dm_udev_get_checking ( ) ;
}
2005-01-06 01:00:40 +03:00
static int _add_dev_node ( const char * dev_name , uint32_t major , uint32_t minor ,
2011-06-28 01:43:58 +04:00
uid_t uid , gid_t gid , mode_t mode , int warn_if_udev_failed )
2001-12-05 19:41:52 +03:00
{
2002-03-19 02:39:42 +03:00
char path [ PATH_MAX ] ;
struct stat info ;
2012-08-16 22:06:07 +04:00
dev_t dev = MKDEV ( ( dev_t ) major , minor ) ;
2005-01-06 01:00:40 +03:00
mode_t old_mask ;
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
_build_dev_path ( path , sizeof ( path ) , dev_name ) ;
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
if ( stat ( path , & info ) > = 0 ) {
if ( ! S_ISBLK ( info . st_mode ) ) {
log_error ( " A non-block device file at '%s' "
" is already present " , path ) ;
return 0 ;
}
2001-12-05 19:41:52 +03:00
2005-01-06 01:00:40 +03:00
/* If right inode already exists we don't touch uid etc. */
2002-03-19 02:39:42 +03:00
if ( info . st_rdev = = dev )
return 1 ;
2001-12-05 19:41:52 +03:00
2002-03-19 02:39:42 +03:00
if ( unlink ( path ) < 0 ) {
log_error ( " Unable to unlink device node for '%s' " ,
dev_name ) ;
return 0 ;
}
2011-06-28 01:43:58 +04:00
} else if ( _warn_if_op_needed ( warn_if_udev_failed ) )
2009-08-03 22:33:08 +04:00
log_warn ( " %s not set up by udev: Falling back to direct "
" node creation. " , path ) ;
2001-12-05 19:41:52 +03:00
2010-12-13 13:43:56 +03:00
( void ) dm_prepare_selinux_context ( path , S_IFBLK ) ;
2005-01-06 01:00:40 +03:00
old_mask = umask ( 0 ) ;
if ( mknod ( path , S_IFBLK | mode , dev ) < 0 ) {
2011-01-12 23:42:50 +03:00
log_error ( " %s: mknod for %s failed: %s " , path , dev_name , strerror ( errno ) ) ;
2010-12-13 13:43:56 +03:00
umask ( old_mask ) ;
( void ) dm_prepare_selinux_context ( NULL , 0 ) ;
2002-03-19 02:39:42 +03:00
return 0 ;
}
2005-01-06 01:00:40 +03:00
umask ( old_mask ) ;
2010-12-13 13:43:56 +03:00
( void ) dm_prepare_selinux_context ( NULL , 0 ) ;
2005-01-06 01:00:40 +03:00
if ( chown ( path , uid , gid ) < 0 ) {
2007-07-28 14:23:02 +04:00
log_sys_error ( " chown " , path ) ;
2005-01-06 01:00:40 +03:00
return 0 ;
}
2007-12-14 22:49:27 +03:00
log_debug ( " Created %s " , path ) ;
2002-03-19 02:39:42 +03:00
return 1 ;
2001-12-05 19:41:52 +03:00
}
2011-06-28 01:43:58 +04:00
static int _rm_dev_node ( const char * dev_name , int warn_if_udev_failed )
2009-08-06 19:00:25 +04:00
{
char path [ PATH_MAX ] ;
struct stat info ;
_build_dev_path ( path , sizeof ( path ) , dev_name ) ;
if ( stat ( path , & info ) < 0 )
return 1 ;
2011-06-28 01:43:58 +04:00
else if ( _warn_if_op_needed ( warn_if_udev_failed ) )
2009-08-06 19:00:25 +04:00
log_warn ( " Node %s was not removed by udev. "
" Falling back to direct node removal. " , path ) ;
if ( unlink ( path ) < 0 ) {
log_error ( " Unable to unlink device node for '%s' " , dev_name ) ;
return 0 ;
}
log_debug ( " Removed %s " , path ) ;
return 1 ;
}
2009-10-26 17:29:33 +03:00
static int _rename_dev_node ( const char * old_name , const char * new_name ,
2011-06-28 01:43:58 +04:00
int warn_if_udev_failed )
2002-04-11 16:45:18 +04:00
{
char oldpath [ PATH_MAX ] ;
char newpath [ PATH_MAX ] ;
struct stat info ;
_build_dev_path ( oldpath , sizeof ( oldpath ) , old_name ) ;
_build_dev_path ( newpath , sizeof ( newpath ) , new_name ) ;
2002-04-24 01:47:50 +04:00
if ( stat ( newpath , & info ) = = 0 ) {
2002-04-11 16:45:18 +04:00
if ( ! S_ISBLK ( info . st_mode ) ) {
log_error ( " A non-block device file at '%s' "
" is already present " , newpath ) ;
return 0 ;
}
2011-06-28 01:43:58 +04:00
else if ( _warn_if_op_needed ( warn_if_udev_failed ) ) {
2009-08-06 19:00:25 +04:00
if ( stat ( oldpath , & info ) < 0 & &
errno = = ENOENT )
/* assume udev already deleted this */
return 1 ;
else {
log_warn ( " The node %s should have been renamed to %s "
" by udev but old node is still present. "
" Falling back to direct old node removal. " ,
oldpath , newpath ) ;
2009-10-26 17:29:33 +03:00
return _rm_dev_node ( old_name , 0 ) ;
2009-08-06 19:00:25 +04:00
}
}
2002-04-11 16:45:18 +04:00
if ( unlink ( newpath ) < 0 ) {
2003-01-22 00:25:11 +03:00
if ( errno = = EPERM ) {
2002-04-24 01:47:50 +04:00
/* devfs, entry has already been renamed */
return 1 ;
2002-04-11 16:45:18 +04:00
}
log_error ( " Unable to unlink device node for '%s' " ,
new_name ) ;
return 0 ;
}
}
2011-06-28 01:43:58 +04:00
else if ( _warn_if_op_needed ( warn_if_udev_failed ) )
2009-08-06 19:00:25 +04:00
log_warn ( " The node %s should have been renamed to %s "
" by udev but new node is not present. "
" Falling back to direct node rename. " ,
oldpath , newpath ) ;
2002-04-11 16:45:18 +04:00
if ( rename ( oldpath , newpath ) < 0 ) {
2002-04-24 01:47:50 +04:00
log_error ( " Unable to rename device node from '%s' to '%s' " ,
old_name , new_name ) ;
2002-04-11 16:45:18 +04:00
return 0 ;
}
2007-12-14 22:49:27 +03:00
log_debug ( " Renamed %s to %s " , oldpath , newpath ) ;
2002-04-11 16:45:18 +04:00
return 1 ;
}
2007-11-30 19:42:26 +03:00
# ifdef linux
static int _open_dev_node ( const char * dev_name )
{
int fd = - 1 ;
char path [ PATH_MAX ] ;
_build_dev_path ( path , sizeof ( path ) , dev_name ) ;
if ( ( fd = open ( path , O_RDONLY , 0 ) ) < 0 )
log_sys_error ( " open " , path ) ;
return fd ;
}
2012-01-09 16:26:14 +04:00
int get_dev_node_read_ahead ( const char * dev_name , uint32_t major , uint32_t minor ,
uint32_t * read_ahead )
2007-11-30 17:59:57 +03:00
{
2012-01-09 16:26:14 +04:00
char buf [ 24 ] ;
int len ;
2007-11-30 19:42:26 +03:00
int r = 1 ;
int fd ;
2007-12-05 17:11:26 +03:00
long read_ahead_long ;
2007-11-30 19:42:26 +03:00
2012-01-09 16:26:14 +04:00
/*
* If we know the device number , use sysfs if we can .
* Otherwise use BLKRAGET ioctl .
*/
if ( * _sysfs_dir & & major ! = 0 ) {
if ( dm_snprintf ( _path0 , sizeof ( _path0 ) , " %sdev/block/% " PRIu32
" :% " PRIu32 " /bdi/read_ahead_kb " , _sysfs_dir ,
major , minor ) < 0 ) {
log_error ( " Failed to build sysfs_path. " ) ;
return 0 ;
}
if ( ( fd = open ( _path0 , O_RDONLY , 0 ) ) ! = - 1 ) {
/* Reading from sysfs, expecting number\n */
2012-02-08 15:05:04 +04:00
if ( ( len = read ( fd , buf , sizeof ( buf ) - 1 ) ) < 1 ) {
2012-01-09 16:26:14 +04:00
log_sys_error ( " read " , _path0 ) ;
r = 0 ;
} else {
buf [ len ] = 0 ; /* kill \n and ensure \0 */
* read_ahead = atoi ( buf ) * 2 ;
log_debug ( " %s (%d:%d): read ahead is % " PRIu32 ,
dev_name , major , minor , * read_ahead ) ;
}
if ( close ( fd ) )
log_sys_debug ( " close " , _path0 ) ;
return r ;
}
log_sys_debug ( " open " , _path0 ) ;
/* Fall back to use dev_name */
}
/*
* Open / close dev_name may block the process
* ( i . e . overfilled thin pool volume )
*/
2007-12-13 05:25:45 +03:00
if ( ! * dev_name ) {
log_error ( " Empty device name passed to BLKRAGET " ) ;
return 0 ;
}
2007-11-30 19:42:26 +03:00
if ( ( fd = _open_dev_node ( dev_name ) ) < 0 )
2007-11-30 19:44:42 +03:00
return_0 ;
2007-11-30 19:42:26 +03:00
2007-12-05 17:11:26 +03:00
if ( ioctl ( fd , BLKRAGET , & read_ahead_long ) ) {
2007-11-30 19:42:26 +03:00
log_sys_error ( " BLKRAGET " , dev_name ) ;
2007-12-05 17:11:26 +03:00
* read_ahead = 0 ;
2007-11-30 19:42:26 +03:00
r = 0 ;
2012-01-09 16:26:14 +04:00
} else {
2007-12-05 17:11:26 +03:00
* read_ahead = ( uint32_t ) read_ahead_long ;
2007-11-30 19:42:26 +03:00
log_debug ( " %s: read ahead is % " PRIu32 , dev_name , * read_ahead ) ;
2007-12-05 17:11:26 +03:00
}
2007-11-30 19:42:26 +03:00
2007-12-04 01:48:36 +03:00
if ( close ( fd ) )
2012-01-09 16:26:14 +04:00
log_sys_debug ( " close " , dev_name ) ;
2007-11-30 19:42:26 +03:00
return r ;
2007-11-30 17:59:57 +03:00
}
2012-01-09 16:26:14 +04:00
static int _set_read_ahead ( const char * dev_name , uint32_t major , uint32_t minor ,
uint32_t read_ahead )
2007-11-30 17:59:57 +03:00
{
2012-01-09 16:26:14 +04:00
char buf [ 24 ] ;
int len ;
2007-11-30 19:42:26 +03:00
int r = 1 ;
int fd ;
2007-12-05 17:11:26 +03:00
long read_ahead_long = ( long ) read_ahead ;
2007-11-30 19:42:26 +03:00
2012-01-09 16:26:14 +04:00
log_debug ( " %s (%d:%d): Setting read ahead to % " PRIu32 , dev_name ,
major , minor , read_ahead ) ;
/*
* If we know the device number , use sysfs if we can .
* Otherwise use BLKRASET ioctl . RA is set after resume .
*/
if ( * _sysfs_dir & & major ! = 0 ) {
if ( dm_snprintf ( _path0 , sizeof ( _path0 ) , " %sdev/block/% " PRIu32
" :% " PRIu32 " /bdi/read_ahead_kb " ,
_sysfs_dir , major , minor ) < 0 ) {
log_error ( " Failed to build sysfs_path. " ) ;
return 0 ;
}
/* Sysfs is kB based, round up to kB */
if ( ( len = dm_snprintf ( buf , sizeof ( buf ) , " % " PRIu32 ,
( read_ahead + 1 ) / 2 ) ) < 0 ) {
log_error ( " Failed to build size in kB. " ) ;
return 0 ;
}
if ( ( fd = open ( _path0 , O_WRONLY , 0 ) ) ! = - 1 ) {
if ( write ( fd , buf , len ) < len ) {
log_sys_error ( " write " , _path0 ) ;
r = 0 ;
}
if ( close ( fd ) )
log_sys_debug ( " close " , _path0 ) ;
return r ;
}
log_sys_debug ( " open " , _path0 ) ;
/* Fall back to use dev_name */
}
2007-12-13 05:25:45 +03:00
if ( ! * dev_name ) {
log_error ( " Empty device name passed to BLKRAGET " ) ;
return 0 ;
}
2007-11-30 19:42:26 +03:00
if ( ( fd = _open_dev_node ( dev_name ) ) < 0 )
return_0 ;
2007-12-05 17:11:26 +03:00
if ( ioctl ( fd , BLKRASET , read_ahead_long ) ) {
2007-11-30 19:42:26 +03:00
log_sys_error ( " BLKRASET " , dev_name ) ;
r = 0 ;
}
2007-12-04 01:48:36 +03:00
if ( close ( fd ) )
2012-01-09 16:26:14 +04:00
log_sys_debug ( " close " , dev_name ) ;
2007-11-30 19:42:26 +03:00
return r ;
2007-11-30 17:59:57 +03:00
}
2012-01-09 16:26:14 +04:00
static int _set_dev_node_read_ahead ( const char * dev_name ,
uint32_t major , uint32_t minor ,
uint32_t read_ahead , uint32_t read_ahead_flags )
2007-11-30 17:59:57 +03:00
{
uint32_t current_read_ahead ;
if ( read_ahead = = DM_READ_AHEAD_AUTO )
return 1 ;
if ( read_ahead = = DM_READ_AHEAD_NONE )
read_ahead = 0 ;
if ( read_ahead_flags & DM_READ_AHEAD_MINIMUM_FLAG ) {
2012-01-09 16:26:14 +04:00
if ( ! get_dev_node_read_ahead ( dev_name , major , minor , & current_read_ahead ) )
2007-11-30 17:59:57 +03:00
return_0 ;
if ( current_read_ahead > read_ahead ) {
2007-12-05 21:57:34 +03:00
log_debug ( " %s: retaining kernel read ahead of % " PRIu32
" (requested % " PRIu32 " ) " ,
2007-11-30 17:59:57 +03:00
dev_name , current_read_ahead , read_ahead ) ;
return 1 ;
}
}
2012-01-09 16:26:14 +04:00
return _set_read_ahead ( dev_name , major , minor , read_ahead ) ;
2007-11-30 17:59:57 +03:00
}
2007-11-30 19:42:26 +03:00
# else
int get_dev_node_read_ahead ( const char * dev_name , uint32_t * read_ahead )
{
* read_ahead = 0 ;
return 1 ;
}
2012-01-09 16:26:14 +04:00
static int _set_dev_node_read_ahead ( const char * dev_name ,
uint32_t major , uint32_t minor ,
uint32_t read_ahead , uint32_t read_ahead_flags )
2007-11-30 19:42:26 +03:00
{
return 1 ;
}
# endif
2003-07-02 01:20:58 +04:00
typedef enum {
NODE_ADD ,
NODE_DEL ,
2007-11-30 17:59:57 +03:00
NODE_RENAME ,
2011-02-04 22:14:39 +03:00
NODE_READ_AHEAD ,
NUM_NODES
2003-07-02 01:20:58 +04:00
} node_op_t ;
static int _do_node_op ( node_op_t type , const char * dev_name , uint32_t major ,
2005-01-06 01:00:40 +03:00
uint32_t minor , uid_t uid , gid_t gid , mode_t mode ,
2007-11-30 17:59:57 +03:00
const char * old_name , uint32_t read_ahead ,
2011-06-28 01:43:58 +04:00
uint32_t read_ahead_flags , int warn_if_udev_failed )
2003-07-02 01:20:58 +04:00
{
switch ( type ) {
case NODE_ADD :
2009-10-26 17:29:33 +03:00
return _add_dev_node ( dev_name , major , minor , uid , gid ,
2011-06-28 01:43:58 +04:00
mode , warn_if_udev_failed ) ;
2003-07-02 01:20:58 +04:00
case NODE_DEL :
2011-06-28 01:43:58 +04:00
return _rm_dev_node ( dev_name , warn_if_udev_failed ) ;
2003-07-02 01:20:58 +04:00
case NODE_RENAME :
2011-06-28 01:43:58 +04:00
return _rename_dev_node ( old_name , dev_name , warn_if_udev_failed ) ;
2007-11-30 17:59:57 +03:00
case NODE_READ_AHEAD :
2012-01-09 16:26:14 +04:00
return _set_dev_node_read_ahead ( dev_name , major , minor ,
read_ahead , read_ahead_flags ) ;
2011-02-05 01:07:43 +03:00
default :
; /* NOTREACHED */
2003-07-02 01:20:58 +04:00
}
return 1 ;
}
2008-11-04 01:14:30 +03:00
static DM_LIST_INIT ( _node_ops ) ;
2011-02-04 22:14:39 +03:00
static int _count_node_ops [ NUM_NODES ] ;
2003-07-02 01:20:58 +04:00
struct node_op_parms {
2008-11-04 01:14:30 +03:00
struct dm_list list ;
2003-07-02 01:20:58 +04:00
node_op_t type ;
char * dev_name ;
uint32_t major ;
uint32_t minor ;
2005-01-06 01:00:40 +03:00
uid_t uid ;
gid_t gid ;
mode_t mode ;
2007-11-30 17:59:57 +03:00
uint32_t read_ahead ;
uint32_t read_ahead_flags ;
2003-07-02 01:20:58 +04:00
char * old_name ;
2011-06-28 01:43:58 +04:00
int warn_if_udev_failed ;
unsigned rely_on_udev ;
2003-07-02 01:20:58 +04:00
char names [ 0 ] ;
} ;
static void _store_str ( char * * pos , char * * ptr , const char * str )
{
strcpy ( * pos , str ) ;
* ptr = * pos ;
* pos + = strlen ( * ptr ) + 1 ;
}
2011-02-04 22:14:39 +03:00
static void _del_node_op ( struct node_op_parms * nop )
{
_count_node_ops [ nop - > type ] - - ;
dm_list_del ( & nop - > list ) ;
dm_free ( nop ) ;
}
/* Check if there is other the type of node operation stacked */
static int _other_node_ops ( node_op_t type )
{
2011-03-30 16:14:36 +04:00
unsigned i ;
2011-02-04 22:14:39 +03:00
for ( i = 0 ; i < NUM_NODES ; i + + )
if ( type ! = i & & _count_node_ops [ i ] )
return 1 ;
return 0 ;
}
2011-06-28 01:43:58 +04:00
static void _log_node_op ( const char * action_str , struct node_op_parms * nop )
2011-02-04 22:14:39 +03:00
{
2011-06-28 02:38:53 +04:00
const char * rely = nop - > rely_on_udev ? " [trust_udev] " : " " ;
const char * verify = nop - > warn_if_udev_failed ? " [verify_udev] " : " " ;
2011-06-28 01:43:58 +04:00
switch ( nop - > type ) {
case NODE_ADD :
2011-06-28 02:38:53 +04:00
log_debug ( " %s: %s NODE_ADD (% " PRIu32 " ,% " PRIu32 " ) %u:%u 0%o%s%s " ,
nop - > dev_name , action_str , nop - > major , nop - > minor , nop - > uid , nop - > gid , nop - > mode ,
rely , verify ) ;
2011-06-28 01:43:58 +04:00
break ;
case NODE_DEL :
2011-06-28 02:38:53 +04:00
log_debug ( " %s: %s NODE_DEL%s%s " , nop - > dev_name , action_str , rely , verify ) ;
2011-06-28 01:43:58 +04:00
break ;
case NODE_RENAME :
2011-06-28 02:38:53 +04:00
log_debug ( " %s: %s NODE_RENAME to %s%s%s " , nop - > old_name , action_str , nop - > dev_name , rely , verify ) ;
2011-06-28 01:43:58 +04:00
break ;
case NODE_READ_AHEAD :
2011-06-28 02:38:53 +04:00
log_debug ( " %s: %s NODE_READ_AHEAD % " PRIu32 " (flags=% " PRIu32 " )%s%s " ,
nop - > dev_name , action_str , nop - > read_ahead , nop - > read_ahead_flags , rely , verify ) ;
2011-06-28 01:43:58 +04:00
break ;
default :
; /* NOTREACHED */
}
2011-02-04 22:14:39 +03:00
}
2003-07-02 01:20:58 +04:00
static int _stack_node_op ( node_op_t type , const char * dev_name , uint32_t major ,
2005-01-06 01:00:40 +03:00
uint32_t minor , uid_t uid , gid_t gid , mode_t mode ,
2007-11-30 17:59:57 +03:00
const char * old_name , uint32_t read_ahead ,
2011-06-28 01:43:58 +04:00
uint32_t read_ahead_flags , int warn_if_udev_failed ,
unsigned rely_on_udev )
2003-07-02 01:20:58 +04:00
{
struct node_op_parms * nop ;
2008-11-04 01:14:30 +03:00
struct dm_list * noph , * nopht ;
2003-07-02 01:20:58 +04:00
size_t len = strlen ( dev_name ) + strlen ( old_name ) + 2 ;
char * pos ;
2007-12-14 22:49:27 +03:00
/*
2011-06-28 01:43:58 +04:00
* Note : warn_if_udev_failed must have valid content
2007-12-14 22:49:27 +03:00
*/
2011-02-04 22:14:39 +03:00
if ( ( type = = NODE_DEL ) & & _other_node_ops ( type ) )
/*
* Ignore any outstanding operations on the node if deleting it .
*/
2008-11-04 01:14:30 +03:00
dm_list_iterate_safe ( noph , nopht , & _node_ops ) {
nop = dm_list_item ( noph , struct node_op_parms ) ;
2007-12-14 22:49:27 +03:00
if ( ! strcmp ( dev_name , nop - > dev_name ) ) {
2011-06-28 01:43:58 +04:00
_log_node_op ( " Unstacking " , nop ) ;
2011-02-04 22:14:39 +03:00
_del_node_op ( nop ) ;
if ( ! _other_node_ops ( type ) )
break ; /* no other non DEL ops */
2007-12-14 22:49:27 +03:00
}
}
2011-06-28 01:43:58 +04:00
else if ( ( type = = NODE_ADD ) & & _count_node_ops [ NODE_DEL ] )
2011-02-04 22:14:39 +03:00
/*
2011-06-28 01:43:58 +04:00
* Ignore previous DEL operation on added node .
2011-02-05 01:07:43 +03:00
* ( No other operations for this device then DEL could be stacked here ) .
2011-02-04 22:14:39 +03:00
*/
dm_list_iterate_safe ( noph , nopht , & _node_ops ) {
nop = dm_list_item ( noph , struct node_op_parms ) ;
if ( ( nop - > type = = NODE_DEL ) & &
! strcmp ( dev_name , nop - > dev_name ) ) {
2011-06-28 01:43:58 +04:00
_log_node_op ( " Unstacking " , nop ) ;
2011-02-04 22:14:39 +03:00
_del_node_op ( nop ) ;
break ; /* no other DEL ops */
}
}
2011-12-19 01:56:03 +04:00
else if ( type = = NODE_RENAME )
2011-02-04 22:14:39 +03:00
/*
2011-06-28 01:43:58 +04:00
* Ignore any outstanding operations if renaming it .
2011-02-04 22:14:39 +03:00
*
* Currently RENAME operation happens through ' suspend - > resume ' .
* On ' resume ' device is added with read_ahead settings , so it is
* safe to remove any stacked ADD , RENAME , READ_AHEAD operation
* There cannot be any DEL operation on the renamed device .
*/
dm_list_iterate_safe ( noph , nopht , & _node_ops ) {
nop = dm_list_item ( noph , struct node_op_parms ) ;
2011-06-28 13:24:13 +04:00
if ( ! strcmp ( old_name , nop - > dev_name ) ) {
2011-06-28 01:43:58 +04:00
_log_node_op ( " Unstacking " , nop ) ;
2011-02-04 22:14:39 +03:00
_del_node_op ( nop ) ;
2011-06-28 13:24:13 +04:00
}
2011-02-04 22:14:39 +03:00
}
2011-06-28 13:24:13 +04:00
else if ( type = = NODE_READ_AHEAD ) {
/* udev doesn't process readahead */
rely_on_udev = 0 ;
warn_if_udev_failed = 0 ;
}
2007-12-14 22:49:27 +03:00
2005-10-17 02:57:20 +04:00
if ( ! ( nop = dm_malloc ( sizeof ( * nop ) + len ) ) ) {
2003-07-02 01:20:58 +04:00
log_error ( " Insufficient memory to stack mknod operation " ) ;
return 0 ;
}
pos = nop - > names ;
nop - > type = type ;
nop - > major = major ;
nop - > minor = minor ;
2005-01-06 01:00:40 +03:00
nop - > uid = uid ;
nop - > gid = gid ;
nop - > mode = mode ;
2007-11-30 17:59:57 +03:00
nop - > read_ahead = read_ahead ;
nop - > read_ahead_flags = read_ahead_flags ;
2011-06-28 01:43:58 +04:00
nop - > rely_on_udev = rely_on_udev ;
2003-07-02 01:20:58 +04:00
2011-06-28 13:24:13 +04:00
/*
* Clear warn_if_udev_failed if rely_on_udev is set . It doesn ' t get
* checked in this case - this just removes the flag from log messages .
*/
nop - > warn_if_udev_failed = rely_on_udev ? 0 : warn_if_udev_failed ;
2003-07-02 01:20:58 +04:00
_store_str ( & pos , & nop - > dev_name , dev_name ) ;
_store_str ( & pos , & nop - > old_name , old_name ) ;
2011-02-04 22:14:39 +03:00
_count_node_ops [ type ] + + ;
2008-11-04 01:14:30 +03:00
dm_list_add ( & _node_ops , & nop - > list ) ;
2003-07-02 01:20:58 +04:00
2011-06-28 01:43:58 +04:00
_log_node_op ( " Stacking " , nop ) ;
2003-07-02 01:20:58 +04:00
return 1 ;
}
static void _pop_node_ops ( void )
{
2008-11-04 01:14:30 +03:00
struct dm_list * noph , * nopht ;
2003-07-02 01:20:58 +04:00
struct node_op_parms * nop ;
2008-11-04 01:14:30 +03:00
dm_list_iterate_safe ( noph , nopht , & _node_ops ) {
nop = dm_list_item ( noph , struct node_op_parms ) ;
2011-06-28 01:43:58 +04:00
if ( ! nop - > rely_on_udev ) {
_log_node_op ( " Processing " , nop ) ;
_do_node_op ( nop - > type , nop - > dev_name , nop - > major , nop - > minor ,
nop - > uid , nop - > gid , nop - > mode , nop - > old_name ,
nop - > read_ahead , nop - > read_ahead_flags ,
nop - > warn_if_udev_failed ) ;
} else
2011-06-28 02:38:53 +04:00
_log_node_op ( " Skipping " , nop ) ;
2011-02-04 22:14:39 +03:00
_del_node_op ( nop ) ;
2003-07-02 01:20:58 +04:00
}
}
2005-01-06 01:00:40 +03:00
int add_dev_node ( const char * dev_name , uint32_t major , uint32_t minor ,
2011-06-28 01:43:58 +04:00
uid_t uid , gid_t gid , mode_t mode , int check_udev , unsigned rely_on_udev )
2003-07-02 01:20:58 +04:00
{
2009-10-26 17:29:33 +03:00
return _stack_node_op ( NODE_ADD , dev_name , major , minor , uid ,
2011-06-28 01:43:58 +04:00
gid , mode , " " , 0 , 0 , check_udev , rely_on_udev ) ;
2003-07-02 01:20:58 +04:00
}
2011-06-28 01:43:58 +04:00
int rename_dev_node ( const char * old_name , const char * new_name , int check_udev , unsigned rely_on_udev )
2003-07-02 01:20:58 +04:00
{
2009-10-26 17:29:33 +03:00
return _stack_node_op ( NODE_RENAME , new_name , 0 , 0 , 0 ,
2011-06-28 01:43:58 +04:00
0 , 0 , old_name , 0 , 0 , check_udev , rely_on_udev ) ;
2003-07-02 01:20:58 +04:00
}
2011-06-28 01:43:58 +04:00
int rm_dev_node ( const char * dev_name , int check_udev , unsigned rely_on_udev )
2003-07-02 01:20:58 +04:00
{
2009-10-26 17:29:33 +03:00
return _stack_node_op ( NODE_DEL , dev_name , 0 , 0 , 0 ,
2011-06-28 01:43:58 +04:00
0 , 0 , " " , 0 , 0 , check_udev , rely_on_udev ) ;
2007-11-30 17:59:57 +03:00
}
2012-01-09 16:26:14 +04:00
int set_dev_node_read_ahead ( const char * dev_name ,
uint32_t major , uint32_t minor ,
uint32_t read_ahead , uint32_t read_ahead_flags )
2007-11-30 17:59:57 +03:00
{
if ( read_ahead = = DM_READ_AHEAD_AUTO )
return 1 ;
2012-01-09 16:26:14 +04:00
return _stack_node_op ( NODE_READ_AHEAD , dev_name , major , minor , 0 , 0 ,
2011-06-28 01:43:58 +04:00
0 , " " , read_ahead , read_ahead_flags , 0 , 0 ) ;
2003-07-02 01:20:58 +04:00
}
void update_devs ( void )
{
_pop_node_ops ( ) ;
}
2011-09-22 21:17:07 +04:00
static int _canonicalize_and_set_dir ( const char * src , const char * suffix , size_t max_len , char * dir )
2001-12-05 19:41:52 +03:00
{
2007-10-09 16:14:48 +04:00
size_t len ;
const char * slash ;
2011-09-22 21:17:07 +04:00
if ( * src ! = ' / ' ) {
log_debug ( " Invalid directory value, %s: "
" not an absolute name. " , src ) ;
2007-10-09 16:14:48 +04:00
return 0 ;
}
2011-09-22 21:17:07 +04:00
len = strlen ( src ) ;
slash = src [ len - 1 ] = = ' / ' ? " " : " / " ;
2007-10-09 16:14:48 +04:00
2011-09-22 21:17:07 +04:00
if ( dm_snprintf ( dir , max_len , " %s%s%s " , src , slash , suffix ? suffix : " " ) < 0 ) {
log_debug ( " Invalid directory value, %s: name too long. " , src ) ;
2007-10-09 16:14:48 +04:00
return 0 ;
}
2002-03-19 02:39:42 +03:00
return 1 ;
2001-12-05 19:41:52 +03:00
}
2011-09-22 21:17:07 +04:00
int dm_set_dev_dir ( const char * dev_dir )
{
return _canonicalize_and_set_dir ( dev_dir , DM_DIR , sizeof _dm_dir , _dm_dir ) ;
}
2001-12-05 19:41:52 +03:00
const char * dm_dir ( void )
{
2002-03-19 02:39:42 +03:00
return _dm_dir ;
2001-12-05 19:41:52 +03:00
}
2005-10-17 02:57:20 +04:00
2011-09-22 21:17:07 +04:00
int dm_set_sysfs_dir ( const char * sysfs_dir )
{
if ( ! sysfs_dir | | ! * sysfs_dir ) {
_sysfs_dir [ 0 ] = ' \0 ' ;
return 1 ;
}
else
return _canonicalize_and_set_dir ( sysfs_dir , NULL , sizeof _sysfs_dir , _sysfs_dir ) ;
}
const char * dm_sysfs_dir ( void )
{
return _sysfs_dir ;
}
2012-01-10 06:03:31 +04:00
/*
* Replace existing uuid_prefix provided it isn ' t too long .
*/
int dm_set_uuid_prefix ( const char * uuid_prefix )
{
if ( ! uuid_prefix )
return_0 ;
if ( strlen ( uuid_prefix ) > DM_MAX_UUID_PREFIX_LEN ) {
log_error ( " New uuid prefix %s too long. " , uuid_prefix ) ;
return 0 ;
}
strcpy ( _default_uuid_prefix , uuid_prefix ) ;
return 1 ;
}
const char * dm_uuid_prefix ( void )
{
return _default_uuid_prefix ;
}
2012-01-11 16:34:44 +04:00
static int _sysfs_get_dm_name ( uint32_t major , uint32_t minor , char * buf , size_t buf_size )
{
2012-02-13 18:39:24 +04:00
char * sysfs_path , * temp_buf = NULL ;
2012-01-26 01:47:18 +04:00
FILE * fp = NULL ;
int r = 0 ;
2012-02-13 14:49:28 +04:00
size_t len ;
2012-01-11 16:34:44 +04:00
if ( ! ( sysfs_path = dm_malloc ( PATH_MAX ) ) | |
! ( temp_buf = dm_malloc ( PATH_MAX ) ) ) {
log_error ( " _sysfs_get_dm_name: failed to allocate temporary buffers " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
if ( dm_snprintf ( sysfs_path , PATH_MAX , " %sdev/block/% " PRIu32 " :% " PRIu32
" /dm/name " , _sysfs_dir , major , minor ) < 0 ) {
log_error ( " _sysfs_get_dm_name: dm_snprintf failed " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
if ( ! ( fp = fopen ( sysfs_path , " r " ) ) ) {
if ( errno ! = ENOENT )
log_sys_error ( " fopen " , sysfs_path ) ;
else
log_sys_debug ( " fopen " , sysfs_path ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
if ( ! fgets ( temp_buf , PATH_MAX , fp ) ) {
log_sys_error ( " fgets " , sysfs_path ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
2012-02-13 14:49:28 +04:00
len = strlen ( temp_buf ) ;
if ( len > buf_size ) {
2012-01-11 16:34:44 +04:00
log_error ( " _sysfs_get_dm_name: supplied buffer too small " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
2012-02-13 14:49:28 +04:00
temp_buf [ len ? len - 1 : 0 ] = ' \0 ' ; /* \n */
strcpy ( buf , temp_buf ) ;
2012-01-26 01:47:18 +04:00
r = 1 ;
2012-02-13 14:49:28 +04:00
bad :
2012-01-26 01:47:18 +04:00
if ( fp & & fclose ( fp ) )
log_sys_error ( " fclose " , sysfs_path ) ;
2012-01-11 16:34:44 +04:00
dm_free ( temp_buf ) ;
2012-02-13 18:39:24 +04:00
dm_free ( sysfs_path ) ;
2012-01-26 01:47:18 +04:00
return r ;
2012-01-11 16:34:44 +04:00
}
static int _sysfs_get_kernel_name ( uint32_t major , uint32_t minor , char * buf , size_t buf_size )
{
2012-02-13 18:39:24 +04:00
char * name , * sysfs_path , * temp_buf = NULL ;
2012-01-11 16:34:44 +04:00
ssize_t size ;
2012-02-13 14:49:28 +04:00
size_t len ;
int r = 0 ;
2012-01-11 16:34:44 +04:00
if ( ! ( sysfs_path = dm_malloc ( PATH_MAX ) ) | |
! ( temp_buf = dm_malloc ( PATH_MAX ) ) ) {
log_error ( " _sysfs_get_kernel_name: failed to allocate temporary buffers " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
if ( dm_snprintf ( sysfs_path , PATH_MAX , " %sdev/block/% " PRIu32 " :% " PRIu32 ,
_sysfs_dir , major , minor ) < 0 ) {
log_error ( " _sysfs_get_kernel_name: dm_snprintf failed " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
2012-02-08 15:05:04 +04:00
if ( ( size = readlink ( sysfs_path , temp_buf , PATH_MAX - 1 ) ) < 0 ) {
2012-01-11 16:34:44 +04:00
if ( errno ! = ENOENT )
log_sys_error ( " readlink " , sysfs_path ) ;
else
log_sys_debug ( " readlink " , sysfs_path ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
temp_buf [ size ] = ' \0 ' ;
if ( ! ( name = strrchr ( temp_buf , ' / ' ) ) ) {
log_error ( " Could not locate device kernel name in sysfs path %s " , temp_buf ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
name + = 1 ;
2012-02-13 14:49:28 +04:00
len = size - ( name - temp_buf ) + 1 ;
2012-01-11 16:34:44 +04:00
2012-02-13 14:49:28 +04:00
if ( len > buf_size ) {
2012-01-11 16:34:44 +04:00
log_error ( " _sysfs_get_kernel_name: output buffer too small " ) ;
2012-02-13 14:49:28 +04:00
goto bad ;
2012-01-11 16:34:44 +04:00
}
2012-02-13 14:49:28 +04:00
strcpy ( buf , name ) ;
r = 1 ;
bad :
2012-01-11 16:34:44 +04:00
dm_free ( temp_buf ) ;
2012-02-13 18:39:24 +04:00
dm_free ( sysfs_path ) ;
2012-01-11 16:34:44 +04:00
2012-02-13 14:49:28 +04:00
return r ;
2012-01-11 16:34:44 +04:00
}
int dm_device_get_name ( uint32_t major , uint32_t minor , int prefer_kernel_name ,
char * buf , size_t buf_size )
{
if ( ! * _sysfs_dir )
return 0 ;
/*
* device - mapper devices and prefer_kernel_name = 0
* get dm name by reading / sys / dev / block / major : minor / dm / name ,
* fallback to _sysfs_get_kernel_name if not successful
*/
if ( dm_is_dm_major ( major ) & & ! prefer_kernel_name ) {
if ( _sysfs_get_dm_name ( major , minor , buf , buf_size ) )
return 1 ;
else
stack ;
}
/*
* non - device - mapper devices or prefer_kernel_name = 1
* get kernel name using readlink / sys / dev / block / major : minor - > . . . / dm - X
*/
return _sysfs_get_kernel_name ( major , minor , buf , buf_size ) ;
}
2011-09-22 21:23:35 +04:00
int dm_device_has_holders ( uint32_t major , uint32_t minor )
{
char sysfs_path [ PATH_MAX ] ;
struct stat st ;
if ( ! * _sysfs_dir )
return 0 ;
if ( dm_snprintf ( sysfs_path , PATH_MAX , " %sdev/block/% " PRIu32
" :% " PRIu32 " /holders " , _sysfs_dir , major , minor ) < 0 ) {
log_error ( " sysfs_path dm_snprintf failed " ) ;
return 0 ;
}
if ( stat ( sysfs_path , & st ) ) {
log_sys_error ( " stat " , sysfs_path ) ;
return 0 ;
}
return ! dm_is_empty_dir ( sysfs_path ) ;
}
static int _mounted_fs_on_device ( const char * kernel_dev_name )
{
char sysfs_path [ PATH_MAX ] ;
struct dirent * dirent ;
DIR * d ;
struct stat st ;
int r = 0 ;
if ( dm_snprintf ( sysfs_path , PATH_MAX , " %sfs " , _sysfs_dir ) < 0 ) {
log_error ( " sysfs_path dm_snprintf failed " ) ;
return 0 ;
}
if ( ! ( d = opendir ( sysfs_path ) ) ) {
if ( errno ! = ENOENT )
log_sys_error ( " opendir " , sysfs_path ) ;
return 0 ;
}
while ( ( dirent = readdir ( d ) ) ) {
if ( ! strcmp ( dirent - > d_name , " . " ) | | ! strcmp ( dirent - > d_name , " .. " ) )
continue ;
if ( dm_snprintf ( sysfs_path , PATH_MAX , " %sfs/%s/%s " ,
_sysfs_dir , dirent - > d_name , kernel_dev_name ) < 0 ) {
log_error ( " sysfs_path dm_snprintf failed " ) ;
break ;
}
if ( ! stat ( sysfs_path , & st ) ) {
/* found! */
r = 1 ;
break ;
}
else if ( errno ! = ENOENT ) {
log_sys_error ( " stat " , sysfs_path ) ;
break ;
}
}
if ( closedir ( d ) )
log_error ( " _fs_present_on_device: %s: closedir failed " , kernel_dev_name ) ;
return r ;
}
int dm_device_has_mounted_fs ( uint32_t major , uint32_t minor )
{
2012-01-11 16:34:44 +04:00
char kernel_dev_name [ PATH_MAX ] ;
2011-09-22 21:23:35 +04:00
/* Get kernel device name first */
2012-01-11 16:34:44 +04:00
if ( ! dm_device_get_name ( major , minor , 1 , kernel_dev_name , PATH_MAX ) )
2011-09-22 21:23:35 +04:00
return 0 ;
/* Check /sys/fs/<fs_name>/<kernel_dev_name> presence */
return _mounted_fs_on_device ( kernel_dev_name ) ;
}
2005-10-17 02:57:20 +04:00
int dm_mknodes ( const char * name )
{
struct dm_task * dmt ;
int r = 0 ;
if ( ! ( dmt = dm_task_create ( DM_DEVICE_MKNODES ) ) )
return 0 ;
if ( name & & ! dm_task_set_name ( dmt , name ) )
goto out ;
if ( ! dm_task_no_open_count ( dmt ) )
goto out ;
r = dm_task_run ( dmt ) ;
out :
dm_task_destroy ( dmt ) ;
return r ;
}
2005-10-17 22:05:39 +04:00
int dm_driver_version ( char * version , size_t size )
{
struct dm_task * dmt ;
int r = 0 ;
if ( ! ( dmt = dm_task_create ( DM_DEVICE_VERSION ) ) )
return 0 ;
if ( ! dm_task_run ( dmt ) )
log_error ( " Failed to get driver version " ) ;
if ( ! dm_task_get_driver_version ( dmt , version , size ) )
goto out ;
r = 1 ;
out :
dm_task_destroy ( dmt ) ;
return r ;
}
2006-02-21 02:55:58 +03:00
2009-07-31 19:53:11 +04:00
# ifndef UDEV_SYNC_SUPPORT
void dm_udev_set_sync_support ( int sync_with_udev )
{
}
int dm_udev_get_sync_support ( void )
{
return 0 ;
}
2010-01-11 18:36:24 +03:00
void dm_udev_set_checking ( int checking )
{
}
int dm_udev_get_checking ( void )
{
return 0 ;
}
2009-10-22 16:55:47 +04:00
int dm_task_set_cookie ( struct dm_task * dmt , uint32_t * cookie , uint16_t flags )
2009-07-31 19:53:11 +04:00
{
2009-11-13 15:43:21 +03:00
if ( dm_cookie_supported ( ) )
dmt - > event_nr = flags < < DM_UDEV_FLAGS_SHIFT ;
2009-07-31 19:53:11 +04:00
* cookie = 0 ;
return 1 ;
}
2009-07-31 21:51:45 +04:00
int dm_udev_complete ( uint32_t cookie )
2009-07-31 19:53:11 +04:00
{
return 1 ;
}
int dm_udev_wait ( uint32_t cookie )
{
2011-03-02 03:29:57 +03:00
update_devs ( ) ;
2009-07-31 19:53:11 +04:00
return 1 ;
}
# else /* UDEV_SYNC_SUPPORT */
2010-08-03 17:06:35 +04:00
static int _check_semaphore_is_supported ( void )
2010-08-03 11:56:03 +04:00
{
int maxid ;
union semun arg ;
struct seminfo seminfo ;
arg . __buf = & seminfo ;
maxid = semctl ( 0 , 0 , SEM_INFO , arg ) ;
if ( maxid < 0 ) {
log_warn ( " Kernel not configured for semaphores (System V IPC). "
" Not using udev synchronisation code. " ) ;
return 0 ;
}
return 1 ;
}
2009-09-11 19:56:06 +04:00
static int _check_udev_is_running ( void )
{
struct udev * udev ;
struct udev_queue * udev_queue ;
int r ;
if ( ! ( udev = udev_new ( ) ) )
2009-09-15 15:41:38 +04:00
goto_bad ;
2009-09-11 19:56:06 +04:00
if ( ! ( udev_queue = udev_queue_new ( udev ) ) ) {
udev_unref ( udev ) ;
2009-09-15 15:41:38 +04:00
goto_bad ;
2009-09-11 19:56:06 +04:00
}
2009-09-15 15:41:38 +04:00
if ( ! ( r = udev_queue_get_udev_is_active ( udev_queue ) ) )
2009-09-11 19:56:06 +04:00
log_debug ( " Udev is not running. "
" Not using udev synchronisation code. " ) ;
udev_queue_unref ( udev_queue ) ;
udev_unref ( udev ) ;
return r ;
2009-09-15 15:41:38 +04:00
bad :
log_error ( " Could not get udev state. Assuming udev is not running. " ) ;
2009-09-11 19:56:06 +04:00
return 0 ;
}
2010-08-03 17:06:35 +04:00
static void _check_udev_sync_requirements_once ( void )
2009-07-31 19:53:11 +04:00
{
2010-08-03 11:56:03 +04:00
if ( _semaphore_supported < 0 )
_semaphore_supported = _check_semaphore_is_supported ( ) ;
2009-09-11 19:56:06 +04:00
if ( _udev_running < 0 )
_udev_running = _check_udev_is_running ( ) ;
2010-08-03 11:56:03 +04:00
}
2009-09-11 19:56:06 +04:00
2010-08-03 11:56:03 +04:00
void dm_udev_set_sync_support ( int sync_with_udev )
{
_check_udev_sync_requirements_once ( ) ;
2009-07-31 19:53:11 +04:00
_sync_with_udev = sync_with_udev ;
}
int dm_udev_get_sync_support ( void )
{
2010-08-03 11:56:03 +04:00
_check_udev_sync_requirements_once ( ) ;
2009-09-11 19:56:06 +04:00
2010-08-03 11:56:03 +04:00
return _semaphore_supported & & dm_cookie_supported ( ) & &
_udev_running & & _sync_with_udev ;
2009-07-31 19:53:11 +04:00
}
2010-01-11 18:36:24 +03:00
void dm_udev_set_checking ( int checking )
{
if ( ( _udev_checking = checking ) )
log_debug ( " DM udev checking enabled " ) ;
else
log_debug ( " DM udev checking disabled " ) ;
}
int dm_udev_get_checking ( void )
{
return _udev_checking ;
}
2009-07-31 19:53:11 +04:00
static int _get_cookie_sem ( uint32_t cookie , int * semid )
{
2009-08-06 19:04:30 +04:00
if ( cookie > > 16 ! = DM_COOKIE_MAGIC ) {
2009-08-03 15:01:26 +04:00
log_error ( " Could not continue to access notification "
" semaphore identified by cookie value % "
2009-08-03 22:01:45 +04:00
PRIu32 " (0x%x). Incorrect cookie prefix. " ,
cookie , cookie ) ;
2009-08-03 15:01:26 +04:00
return 0 ;
}
2009-07-31 19:53:11 +04:00
if ( ( * semid = semget ( ( key_t ) cookie , 1 , 0 ) ) > = 0 )
return 1 ;
switch ( errno ) {
case ENOENT :
log_error ( " Could not find notification "
" semaphore identified by cookie "
" value % " PRIu32 " (0x%x) " ,
cookie , cookie ) ;
break ;
case EACCES :
log_error ( " No permission to access "
" notificaton semaphore identified "
" by cookie value % " PRIu32 " (0x%x) " ,
cookie , cookie ) ;
break ;
default :
log_error ( " Failed to access notification "
" semaphore identified by cookie "
2009-08-03 15:01:26 +04:00
" value % " PRIu32 " (0x%x): %s " ,
cookie , cookie , strerror ( errno ) ) ;
2009-07-31 19:53:11 +04:00
break ;
}
return 0 ;
}
2009-08-05 23:50:08 +04:00
static int _udev_notify_sem_inc ( uint32_t cookie , int semid )
2009-07-31 19:53:11 +04:00
{
struct sembuf sb = { 0 , 1 , 0 } ;
2011-07-08 19:34:47 +04:00
int val ;
2009-07-31 19:53:11 +04:00
2009-08-03 15:01:26 +04:00
if ( semop ( semid , & sb , 1 ) < 0 ) {
2009-08-05 23:50:08 +04:00
log_error ( " semid %d: semop failed for cookie 0x% " PRIx32 " : %s " ,
semid , cookie , strerror ( errno ) ) ;
2009-08-03 15:01:26 +04:00
return 0 ;
}
2011-07-08 19:34:47 +04:00
if ( ( val = semctl ( semid , 0 , GETVAL ) ) < 0 ) {
log_error ( " semid %d: sem_ctl GETVAL failed for "
" cookie 0x% " PRIx32 " : %s " ,
semid , cookie , strerror ( errno ) ) ;
return 0 ;
}
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) incremented to %d " ,
cookie , semid , val ) ;
2009-08-05 23:50:08 +04:00
2009-08-03 15:01:26 +04:00
return 1 ;
2009-07-31 19:53:11 +04:00
}
2009-08-05 23:50:08 +04:00
static int _udev_notify_sem_dec ( uint32_t cookie , int semid )
2009-07-31 19:53:11 +04:00
{
2009-08-03 15:01:26 +04:00
struct sembuf sb = { 0 , - 1 , IPC_NOWAIT } ;
2011-07-08 19:34:47 +04:00
int val ;
if ( ( val = semctl ( semid , 0 , GETVAL ) ) < 0 ) {
log_error ( " semid %d: sem_ctl GETVAL failed for "
" cookie 0x% " PRIx32 " : %s " ,
semid , cookie , strerror ( errno ) ) ;
return 0 ;
}
2009-08-03 15:01:26 +04:00
if ( semop ( semid , & sb , 1 ) < 0 ) {
switch ( errno ) {
case EAGAIN :
2009-08-05 23:50:08 +04:00
log_error ( " semid %d: semop failed for cookie "
" 0x% " PRIx32 " : "
2009-08-03 15:01:26 +04:00
" incorrect semaphore state " ,
2009-08-05 23:50:08 +04:00
semid , cookie ) ;
2009-08-03 15:01:26 +04:00
break ;
default :
2009-08-05 23:50:08 +04:00
log_error ( " semid %d: semop failed for cookie "
" 0x% " PRIx32 " : %s " ,
semid , cookie , strerror ( errno ) ) ;
2009-08-03 15:01:26 +04:00
break ;
}
return 0 ;
}
2009-07-31 19:53:11 +04:00
2011-07-08 19:34:47 +04:00
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) decremented to %d " ,
cookie , semid , val - 1 ) ;
2009-08-05 23:50:08 +04:00
2009-08-03 15:01:26 +04:00
return 1 ;
2009-07-31 19:53:11 +04:00
}
2009-08-05 23:50:08 +04:00
static int _udev_notify_sem_destroy ( uint32_t cookie , int semid )
2009-07-31 19:53:11 +04:00
{
if ( semctl ( semid , 0 , IPC_RMID , 0 ) < 0 ) {
log_error ( " Could not cleanup notification semaphore "
2009-08-03 15:01:26 +04:00
" identified by cookie value % " PRIu32 " (0x%x): %s " ,
cookie , cookie , strerror ( errno ) ) ;
2009-07-31 19:53:11 +04:00
return 0 ;
}
2009-08-05 23:50:08 +04:00
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) destroyed " , cookie ,
semid ) ;
2009-07-31 19:53:11 +04:00
return 1 ;
}
static int _udev_notify_sem_create ( uint32_t * cookie , int * semid )
{
int fd ;
int gen_semid ;
2011-07-08 19:34:47 +04:00
int val ;
2009-07-31 19:53:11 +04:00
uint16_t base_cookie ;
uint32_t gen_cookie ;
2010-05-27 19:02:56 +04:00
union semun sem_arg ;
2009-07-31 19:53:11 +04:00
if ( ( fd = open ( " /dev/urandom " , O_RDONLY ) ) < 0 ) {
log_error ( " Failed to open /dev/urandom "
" to create random cookie value " ) ;
* cookie = 0 ;
return 0 ;
}
/* Generate random cookie value. Be sure it is unique and non-zero. */
do {
/* FIXME Handle non-error returns from read(). Move _io() into libdm? */
if ( read ( fd , & base_cookie , sizeof ( base_cookie ) ) ! = sizeof ( base_cookie ) ) {
log_error ( " Failed to initialize notification cookie " ) ;
goto bad ;
}
2009-08-06 19:04:30 +04:00
gen_cookie = DM_COOKIE_MAGIC < < 16 | base_cookie ;
2009-07-31 19:53:11 +04:00
if ( base_cookie & & ( gen_semid = semget ( ( key_t ) gen_cookie ,
1 , 0600 | IPC_CREAT | IPC_EXCL ) ) < 0 ) {
switch ( errno ) {
case EEXIST :
/* if the semaphore key exists, we
* simply generate another random one */
base_cookie = 0 ;
break ;
case ENOMEM :
log_error ( " Not enough memory to create "
" notification semaphore " ) ;
goto bad ;
case ENOSPC :
log_error ( " Limit for the maximum number "
2009-08-03 15:01:26 +04:00
" of semaphores reached. You can "
" check and set the limits in "
" /proc/sys/kernel/sem. " ) ;
2009-07-31 19:53:11 +04:00
goto bad ;
default :
2009-08-03 15:01:26 +04:00
log_error ( " Failed to create notification "
" semaphore: %s " , strerror ( errno ) ) ;
2009-07-31 19:53:11 +04:00
goto bad ;
}
}
} while ( ! base_cookie ) ;
2009-08-05 23:50:08 +04:00
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) created " ,
gen_cookie , gen_semid ) ;
2010-05-27 19:02:56 +04:00
sem_arg . val = 1 ;
if ( semctl ( gen_semid , 0 , SETVAL , sem_arg ) < 0 ) {
2009-08-03 15:01:26 +04:00
log_error ( " semid %d: semctl failed: %s " , gen_semid , strerror ( errno ) ) ;
2009-07-31 19:53:11 +04:00
/* We have to destroy just created semaphore
* so it won ' t stay in the system . */
2009-08-05 23:50:08 +04:00
( void ) _udev_notify_sem_destroy ( gen_cookie , gen_semid ) ;
2009-07-31 19:53:11 +04:00
goto bad ;
}
2011-07-08 19:34:47 +04:00
if ( ( val = semctl ( gen_semid , 0 , GETVAL ) ) < 0 ) {
log_error ( " semid %d: sem_ctl GETVAL failed for "
" cookie 0x% " PRIx32 " : %s " ,
gen_semid , gen_cookie , strerror ( errno ) ) ;
2012-02-08 15:07:17 +04:00
goto bad ;
2011-07-08 19:34:47 +04:00
}
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) incremented to %d " ,
gen_cookie , gen_semid , val ) ;
2009-08-05 23:50:08 +04:00
2009-07-31 19:53:11 +04:00
if ( close ( fd ) )
stack ;
* semid = gen_semid ;
* cookie = gen_cookie ;
return 1 ;
bad :
if ( close ( fd ) )
stack ;
* cookie = 0 ;
return 0 ;
}
2010-02-15 19:21:33 +03:00
int dm_udev_create_cookie ( uint32_t * cookie )
{
int semid ;
2010-03-23 17:43:18 +03:00
if ( ! dm_udev_get_sync_support ( ) ) {
* cookie = 0 ;
2010-02-15 19:21:33 +03:00
return 1 ;
2010-03-23 17:43:18 +03:00
}
2010-02-15 19:21:33 +03:00
return _udev_notify_sem_create ( cookie , & semid ) ;
}
2011-07-05 20:17:14 +04:00
static const char * _task_type_disp ( int type )
{
switch ( type ) {
case DM_DEVICE_CREATE :
return " CREATE " ;
case DM_DEVICE_RELOAD :
return " RELOAD " ;
case DM_DEVICE_REMOVE :
return " REMOVE " ;
case DM_DEVICE_REMOVE_ALL :
return " REMOVE_ALL " ;
case DM_DEVICE_SUSPEND :
return " SUSPEND " ;
case DM_DEVICE_RESUME :
return " RESUME " ;
case DM_DEVICE_INFO :
return " INFO " ;
case DM_DEVICE_DEPS :
return " DEPS " ;
case DM_DEVICE_RENAME :
return " RENAME " ;
case DM_DEVICE_VERSION :
return " VERSION " ;
case DM_DEVICE_STATUS :
return " STATUS " ;
case DM_DEVICE_TABLE :
return " TABLE " ;
case DM_DEVICE_WAITEVENT :
return " WAITEVENT " ;
case DM_DEVICE_LIST :
return " LIST " ;
case DM_DEVICE_CLEAR :
return " CLEAR " ;
case DM_DEVICE_MKNODES :
return " MKNODES " ;
case DM_DEVICE_LIST_VERSIONS :
return " LIST_VERSIONS " ;
case DM_DEVICE_TARGET_MSG :
return " TARGET_MSG " ;
case DM_DEVICE_SET_GEOMETRY :
return " SET_GEOMETRY " ;
}
return " unknown " ;
}
2009-10-22 16:55:47 +04:00
int dm_task_set_cookie ( struct dm_task * dmt , uint32_t * cookie , uint16_t flags )
2009-07-31 19:53:11 +04:00
{
int semid ;
2009-11-13 15:43:21 +03:00
if ( dm_cookie_supported ( ) )
dmt - > event_nr = flags < < DM_UDEV_FLAGS_SHIFT ;
2009-09-11 20:11:25 +04:00
if ( ! dm_udev_get_sync_support ( ) ) {
2009-11-13 15:43:21 +03:00
* cookie = 0 ;
2009-07-31 19:53:11 +04:00
return 1 ;
}
if ( * cookie ) {
if ( ! _get_cookie_sem ( * cookie , & semid ) )
goto_bad ;
} else if ( ! _udev_notify_sem_create ( cookie , & semid ) )
goto_bad ;
2009-08-05 23:50:08 +04:00
if ( ! _udev_notify_sem_inc ( * cookie , semid ) ) {
2009-07-31 19:53:11 +04:00
log_error ( " Could not set notification semaphore "
" identified by cookie value % " PRIu32 " (0x%x) " ,
* cookie , * cookie ) ;
goto bad ;
}
2009-11-13 15:43:21 +03:00
dmt - > event_nr | = ~ DM_UDEV_FLAGS_MASK & * cookie ;
2009-08-03 22:01:45 +04:00
dmt - > cookie_set = 1 ;
2009-08-05 23:50:08 +04:00
2011-07-05 20:17:14 +04:00
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) assigned to "
" %s task(%d) with flags%s%s%s%s%s%s%s (0x% " PRIx16 " ) " , * cookie , semid , _task_type_disp ( dmt - > type ) , dmt - > type ,
( flags & DM_UDEV_DISABLE_DM_RULES_FLAG ) ? " DISABLE_DM_RULES " : " " ,
( flags & DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG ) ? " DISABLE_SUBSYSTEM_RULES " : " " ,
( flags & DM_UDEV_DISABLE_DISK_RULES_FLAG ) ? " DISABLE_DISK_RULES " : " " ,
( flags & DM_UDEV_DISABLE_OTHER_RULES_FLAG ) ? " DISABLE_OTHER_RULES " : " " ,
( flags & DM_UDEV_LOW_PRIORITY_FLAG ) ? " LOW_PRIORITY " : " " ,
( flags & DM_UDEV_DISABLE_LIBRARY_FALLBACK ) ? " DISABLE_LIBRARY_FALLBACK " : " " ,
( flags & DM_UDEV_PRIMARY_SOURCE_FLAG ) ? " PRIMARY_SOURCE " : " " ,
flags ) ;
2009-08-05 23:50:08 +04:00
2009-07-31 19:53:11 +04:00
return 1 ;
bad :
dmt - > event_nr = 0 ;
return 0 ;
}
2009-07-31 21:51:45 +04:00
int dm_udev_complete ( uint32_t cookie )
2009-07-31 19:53:11 +04:00
{
int semid ;
2009-09-11 20:11:25 +04:00
if ( ! cookie | | ! dm_udev_get_sync_support ( ) )
2009-07-31 19:53:11 +04:00
return 1 ;
if ( ! _get_cookie_sem ( cookie , & semid ) )
return_0 ;
2009-08-05 23:50:08 +04:00
if ( ! _udev_notify_sem_dec ( cookie , semid ) ) {
2009-07-31 19:53:11 +04:00
log_error ( " Could not signal waiting process using notification "
" semaphore identified by cookie value % " PRIu32 " (0x%x) " ,
cookie , cookie ) ;
return 0 ;
}
return 1 ;
}
2011-03-02 03:29:57 +03:00
static int _udev_wait ( uint32_t cookie )
2009-07-31 19:53:11 +04:00
{
int semid ;
struct sembuf sb = { 0 , 0 , 0 } ;
2009-09-11 20:11:25 +04:00
if ( ! cookie | | ! dm_udev_get_sync_support ( ) )
2009-07-31 19:53:11 +04:00
return 1 ;
if ( ! _get_cookie_sem ( cookie , & semid ) )
return_0 ;
2009-08-05 23:50:08 +04:00
if ( ! _udev_notify_sem_dec ( cookie , semid ) ) {
2009-07-31 19:53:11 +04:00
log_error ( " Failed to set a proper state for notification "
" semaphore identified by cookie value % " PRIu32 " (0x%x) "
" to initialize waiting for incoming notifications. " ,
cookie , cookie ) ;
2009-08-05 23:50:08 +04:00
( void ) _udev_notify_sem_destroy ( cookie , semid ) ;
2009-07-31 19:53:11 +04:00
return 0 ;
}
2011-06-28 01:43:58 +04:00
log_debug ( " Udev cookie 0x% " PRIx32 " (semid %d) waiting for zero " ,
2009-08-05 23:50:08 +04:00
cookie , semid ) ;
2009-07-31 19:53:11 +04:00
repeat_wait :
if ( semop ( semid , & sb , 1 ) < 0 ) {
if ( errno = = EINTR )
goto repeat_wait ;
2009-08-06 19:04:30 +04:00
else if ( errno = = EIDRM )
return 1 ;
2009-07-31 19:53:11 +04:00
log_error ( " Could not set wait state for notification semaphore "
2009-08-03 15:01:26 +04:00
" identified by cookie value % " PRIu32 " (0x%x): %s " ,
cookie , cookie , strerror ( errno ) ) ;
2009-08-05 23:50:08 +04:00
( void ) _udev_notify_sem_destroy ( cookie , semid ) ;
2009-07-31 19:53:11 +04:00
return 0 ;
}
2009-08-05 23:50:08 +04:00
return _udev_notify_sem_destroy ( cookie , semid ) ;
2009-07-31 19:53:11 +04:00
}
2011-03-02 03:29:57 +03:00
int dm_udev_wait ( uint32_t cookie )
{
int r = _udev_wait ( cookie ) ;
update_devs ( ) ;
2011-03-02 11:40:28 +03:00
return r ;
2011-03-02 03:29:57 +03:00
}
2009-07-31 19:53:11 +04:00
# endif /* UDEV_SYNC_SUPPORT */