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
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 ;
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
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 ;
}
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 .
*/
2009-09-25 22:13:17 +04:00
static char * _find_dm_name_of_device ( dev_t st_rdev )
2009-09-25 22:08:04 +04:00
{
const char * name ;
char path [ PATH_MAX ] ;
struct dirent * dirent ;
DIR * d ;
struct stat buf ;
char * new_name = NULL ;
if ( ! ( d = opendir ( _dm_dir ) ) ) {
log_sys_error ( " opendir " , _dm_dir ) ;
return NULL ;
}
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 ;
}
if ( stat ( path , & buf ) )
continue ;
if ( buf . st_rdev = = st_rdev ) {
2009-09-25 22:19:09 +04:00
if ( ! ( new_name = dm_strdup ( name ) ) )
log_error ( " dm_task_set_name: strdup(%s) failed " ,
name ) ;
2009-09-25 22:08:04 +04:00
break ;
}
}
if ( closedir ( d ) )
log_sys_error ( " closedir " , _dm_dir ) ;
return new_name ;
}
2001-12-05 19:41:52 +03:00
int dm_task_set_name ( struct dm_task * dmt , const char * name )
{
2001-12-14 16:30:04 +03:00
char * pos ;
2009-09-25 22:08:04 +04:00
char * new_name = NULL ;
2001-12-14 16:30:04 +03:00
char path [ PATH_MAX ] ;
struct stat st1 , st2 ;
2010-11-29 13:11:50 +03:00
dm_free ( dmt - > dev_name ) ;
dmt - > dev_name = NULL ;
2001-12-05 19:41:52 +03:00
2009-09-25 22:08:04 +04:00
/*
* Path supplied for existing device ?
2001-12-14 16:30:04 +03:00
*/
if ( ( pos = strrchr ( name , ' / ' ) ) ) {
2009-01-07 15:17:40 +03:00
if ( dmt - > type = = DM_DEVICE_CREATE ) {
log_error ( " Name \" %s \" invalid. It contains \" / \" . " , name ) ;
return 0 ;
}
2009-09-25 22:08:04 +04:00
if ( stat ( name , & st1 ) ) {
log_error ( " Device %s not found " , name ) ;
return 0 ;
}
/*
* If supplied path points to same device as last component
* under / dev / mapper , use that name directly . Otherwise call
2009-09-25 22:13:17 +04:00
* _find_dm_name_of_device ( ) to scan _dm_dir for a match .
2009-09-25 22:08:04 +04:00
*/
2009-09-25 23:06:05 +04:00
if ( dm_snprintf ( path , sizeof ( path ) , " %s/%s " , _dm_dir ,
pos + 1 ) = = - 1 ) {
log_error ( " Couldn't create path for %s " , pos + 1 ) ;
return 0 ;
}
2001-12-14 16:30:04 +03:00
2009-09-25 22:08:04 +04:00
if ( ! stat ( path , & st2 ) & & ( st1 . st_rdev = = st2 . st_rdev ) )
name = pos + 1 ;
2009-09-25 22:13:17 +04:00
else if ( ( new_name = _find_dm_name_of_device ( st1 . st_rdev ) ) )
2009-09-25 22:08:04 +04:00
name = new_name ;
else {
2009-01-07 15:17:40 +03:00
log_error ( " Device %s not found " , name ) ;
2001-12-14 16:30:04 +03:00
return 0 ;
}
}
2009-01-07 15:17:40 +03:00
if ( strlen ( name ) > = DM_NAME_LEN ) {
log_error ( " Name \" %s \" too long " , name ) ;
2010-11-29 13:11:50 +03:00
dm_free ( new_name ) ;
2009-01-07 15:17:40 +03:00
return 0 ;
}
2009-09-25 22:08:04 +04:00
if ( new_name )
dmt - > dev_name = new_name ;
else if ( ! ( dmt - > dev_name = dm_strdup ( name ) ) ) {
2002-01-18 22:37:26 +03:00
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-01-17 18:36:58 +04:00
int dm_task_set_newname ( struct dm_task * dmt , const char * newname )
{
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 ;
}
if ( ! ( dmt - > newname = dm_strdup ( newname ) ) ) {
log_error ( " dm_task_set_newname: strdup(%s) failed " , newname ) ;
return 0 ;
}
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 )
{
2010-11-29 13:11:50 +03:00
dm_free ( dmt - > uuid ) ;
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 ;
2003-01-22 00:25:11 +03:00
dev_t dev = MKDEV ( 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