2001-10-03 16:41:29 +04:00
/*
2004-03-30 23:35:44 +04:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
2012-02-08 15:15:38 +04:00
* Copyright ( C ) 2004 - 2012 Red Hat , Inc . All rights reserved .
2001-10-03 16:41:29 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
*
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
2007-08-21 00:55:30 +04:00
* of the GNU Lesser General Public License v .2 .1 .
2004-03-30 23:35:44 +04:00
*
2007-08-21 00:55:30 +04:00
* You should have received a copy of the GNU Lesser General Public License
2004-03-30 23:35:44 +04:00
* along with this program ; if not , write to the Free Software Foundation ,
2016-01-21 13:49:46 +03:00
* Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-10-03 16:41:29 +04:00
*/
2018-05-14 12:30:20 +03:00
# include "lib/misc/lib.h"
# include "lib/device/device.h"
# include "lib/metadata/metadata.h"
# include "lib/mm/memlock.h"
2001-10-04 14:13:07 +04:00
2002-12-20 02:25:55 +03:00
# include <limits.h>
2001-10-04 14:13:07 +04:00
# include <sys/stat.h>
2002-07-22 12:10:54 +04:00
# include <fcntl.h>
2002-08-14 18:58:00 +04:00
# include <unistd.h>
2001-10-04 14:13:07 +04:00
# include <sys/ioctl.h>
2003-04-15 17:24:42 +04:00
2013-11-13 17:56:29 +04:00
# ifdef __linux__
2003-04-15 17:24:42 +04:00
# define u64 uint64_t /* Missing without __KERNEL__ */
2003-07-05 02:34:56 +04:00
# undef WNOHANG /* Avoid redefinition */
# undef WUNTRACED /* Avoid redefinition */
2003-04-15 17:24:42 +04:00
# include <linux / fs.h> /* For block ioctl definitions */
# define BLKSIZE_SHIFT SECTOR_SHIFT
2004-01-27 23:53:57 +03:00
# ifndef BLKGETSIZE64 /* fs.h out-of-date */
# define BLKGETSIZE64 _IOR(0x12, 114, size_t)
# endif /* BLKGETSIZE64 */
2011-04-13 01:59:01 +04:00
# ifndef BLKDISCARD
# define BLKDISCARD _IO(0x12,119)
# endif
2003-07-05 02:34:56 +04:00
# else
# include <sys / disk.h>
# define BLKBSZGET DKIOCGETBLOCKSIZE
# define BLKSSZGET DKIOCGETBLOCKSIZE
# define BLKGETSIZE64 DKIOCGETBLOCKCOUNT
# define BLKFLSBUF DKIOCSYNCHRONIZECACHE
# define BLKSIZE_SHIFT 0
2003-11-06 20:14:06 +03:00
# endif
# ifdef O_DIRECT_SUPPORT
2003-07-05 02:34:56 +04:00
# ifndef O_DIRECT
2003-11-06 20:14:06 +03:00
# error O_DIRECT support configured but O_DIRECT definition not found in headers
2003-07-05 02:34:56 +04:00
# endif
2003-04-15 17:24:42 +04:00
# endif
2001-11-13 21:52:52 +03:00
2016-01-15 18:41:27 +03:00
static unsigned _dev_size_seqno = 1 ;
2003-07-05 02:34:56 +04:00
2016-01-15 18:41:27 +03:00
static int _dev_get_size_file ( struct device * dev , uint64_t * size )
2005-05-03 21:28:23 +04:00
{
const char * name = dev_name ( dev ) ;
struct stat info ;
2003-07-05 02:34:56 +04:00
2016-01-15 18:41:27 +03:00
if ( dev - > size_seqno = = _dev_size_seqno ) {
log_very_verbose ( " %s: using cached size % " PRIu64 " sectors " ,
name , dev - > size ) ;
* size = dev - > size ;
return 1 ;
}
2005-05-03 21:28:23 +04:00
if ( stat ( name , & info ) ) {
log_sys_error ( " stat " , name ) ;
return 0 ;
}
* size = info . st_size ;
* size > > = SECTOR_SHIFT ; /* Convert to sectors */
2016-01-15 18:41:27 +03:00
dev - > size = * size ;
dev - > size_seqno = _dev_size_seqno ;
2005-05-03 21:28:23 +04:00
log_very_verbose ( " %s: size is % " PRIu64 " sectors " , name , * size ) ;
return 1 ;
}
2015-03-03 17:37:17 +03:00
static int _dev_get_size_dev ( struct device * dev , uint64_t * size )
2001-10-03 16:41:29 +04:00
{
2001-10-25 18:04:18 +04:00
const char * name = dev_name ( dev ) ;
2018-02-13 17:58:35 +03:00
int fd = dev - > bcache_fd ;
int do_close = 0 ;
2001-10-03 16:41:29 +04:00
2020-05-13 23:47:20 +03:00
if ( dm_list_empty ( & dev - > aliases ) )
return 0 ;
2016-01-15 18:41:27 +03:00
if ( dev - > size_seqno = = _dev_size_seqno ) {
log_very_verbose ( " %s: using cached size % " PRIu64 " sectors " ,
name , dev - > size ) ;
* size = dev - > size ;
return 1 ;
}
2018-02-13 17:58:35 +03:00
if ( fd < = 0 ) {
2020-03-12 18:18:51 +03:00
if ( ! dev_open_readonly_quiet ( dev ) )
2018-02-13 17:58:35 +03:00
return_0 ;
fd = dev_fd ( dev ) ;
do_close = 1 ;
}
2001-10-03 16:41:29 +04:00
2018-02-13 17:58:35 +03:00
if ( ioctl ( fd , BLKGETSIZE64 , size ) < 0 ) {
2003-04-15 17:24:42 +04:00
log_sys_error ( " ioctl BLKGETSIZE64 " , name ) ;
2018-05-11 22:25:08 +03:00
if ( do_close & & ! dev_close_immediate ( dev ) )
2020-09-30 00:48:45 +03:00
stack ;
2001-10-03 16:41:29 +04:00
return 0 ;
}
2003-04-30 19:21:10 +04:00
* size > > = BLKSIZE_SHIFT ; /* Convert to sectors */
2016-01-15 18:41:27 +03:00
dev - > size = * size ;
dev - > size_seqno = _dev_size_seqno ;
2018-05-04 01:12:07 +03:00
log_very_verbose ( " %s: size is % " PRIu64 " sectors " , name , * size ) ;
2018-05-11 22:25:08 +03:00
if ( do_close & & ! dev_close_immediate ( dev ) )
2020-09-30 00:48:45 +03:00
stack ;
2004-12-10 19:01:35 +03:00
2001-10-03 16:41:29 +04:00
return 1 ;
}
2009-05-20 15:09:49 +04:00
static int _dev_read_ahead_dev ( struct device * dev , uint32_t * read_ahead )
{
long read_ahead_long ;
if ( dev - > read_ahead ! = - 1 ) {
* read_ahead = ( uint32_t ) dev - > read_ahead ;
return 1 ;
}
2020-03-12 18:18:51 +03:00
if ( ! dev_open_readonly_quiet ( dev ) ) {
log_error ( " Failed to open to get readahead %s " , dev_name ( dev ) ) ;
2020-09-30 00:48:45 +03:00
return 0 ;
2020-03-12 18:18:51 +03:00
}
2009-05-20 15:09:49 +04:00
if ( ioctl ( dev - > fd , BLKRAGET , & read_ahead_long ) < 0 ) {
log_sys_error ( " ioctl BLKRAGET " , dev_name ( dev ) ) ;
2018-05-11 22:25:08 +03:00
if ( ! dev_close_immediate ( dev ) )
2009-05-20 15:09:49 +04:00
stack ;
return 0 ;
}
* read_ahead = ( uint32_t ) read_ahead_long ;
dev - > read_ahead = read_ahead_long ;
log_very_verbose ( " %s: read_ahead is %u sectors " ,
dev_name ( dev ) , * read_ahead ) ;
2018-05-11 22:25:08 +03:00
if ( ! dev_close_immediate ( dev ) )
2012-02-08 15:15:38 +04:00
stack ;
2009-05-20 15:09:49 +04:00
return 1 ;
}
2011-04-13 01:59:01 +04:00
static int _dev_discard_blocks ( struct device * dev , uint64_t offset_bytes , uint64_t size_bytes )
{
uint64_t discard_range [ 2 ] ;
if ( ! dev_open ( dev ) )
return_0 ;
discard_range [ 0 ] = offset_bytes ;
discard_range [ 1 ] = size_bytes ;
2018-07-08 22:11:01 +03:00
log_debug_devs ( " Discarding % " PRIu64 " bytes offset % " PRIu64 " bytes on %s. %s " ,
size_bytes , offset_bytes , dev_name ( dev ) ,
test_mode ( ) ? " (test mode - suppressed) " : " " ) ;
if ( ! test_mode ( ) & & ioctl ( dev - > fd , BLKDISCARD , & discard_range ) < 0 ) {
2011-04-13 01:59:01 +04:00
log_error ( " %s: BLKDISCARD ioctl at offset % " PRIu64 " size % " PRIu64 " failed: %s. " ,
dev_name ( dev ) , offset_bytes , size_bytes , strerror ( errno ) ) ;
2018-05-11 22:25:08 +03:00
if ( ! dev_close_immediate ( dev ) )
2011-04-13 01:59:01 +04:00
stack ;
/* It doesn't matter if discard failed, so return success. */
return 1 ;
}
2018-05-11 22:25:08 +03:00
if ( ! dev_close_immediate ( dev ) )
2011-04-13 01:59:01 +04:00
stack ;
return 1 ;
}
2019-07-26 22:21:08 +03:00
int dev_get_direct_block_sizes ( struct device * dev , unsigned int * physical_block_size ,
unsigned int * logical_block_size )
{
int fd = dev - > bcache_fd ;
int do_close = 0 ;
unsigned int pbs = 0 ;
unsigned int lbs = 0 ;
if ( dev - > physical_block_size | | dev - > logical_block_size ) {
* physical_block_size = dev - > physical_block_size ;
* logical_block_size = dev - > logical_block_size ;
return 1 ;
}
if ( fd < = 0 ) {
2020-03-12 18:18:51 +03:00
if ( ! dev_open_readonly_quiet ( dev ) )
2019-07-26 22:21:08 +03:00
return 0 ;
fd = dev_fd ( dev ) ;
do_close = 1 ;
}
2019-08-08 23:43:09 +03:00
# ifdef BLKPBSZGET /* not defined before kernel version 2.6.32 (e.g. rhel5) */
2019-07-26 22:21:08 +03:00
/*
* BLKPBSZGET from kernel comment for blk_queue_physical_block_size :
* " the lowest possible sector size that the hardware can operate on
* without reverting to read - modify - write operations "
*/
if ( ioctl ( fd , BLKPBSZGET , & pbs ) ) {
stack ;
pbs = 0 ;
}
2019-08-08 23:43:09 +03:00
# endif
2019-07-26 22:21:08 +03:00
/*
* BLKSSZGET from kernel comment for blk_queue_logical_block_size :
* " the lowest possible block size that the storage device can address. "
*/
if ( ioctl ( fd , BLKSSZGET , & lbs ) ) {
stack ;
lbs = 0 ;
}
dev - > physical_block_size = pbs ;
dev - > logical_block_size = lbs ;
* physical_block_size = pbs ;
* logical_block_size = lbs ;
if ( do_close & & ! dev_close_immediate ( dev ) )
stack ;
return 1 ;
}
2005-05-03 21:28:23 +04:00
/*-----------------------------------------------------------------
* Public functions
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
2016-01-15 18:41:27 +03:00
void dev_size_seqno_inc ( void )
{
_dev_size_seqno + + ;
}
2005-05-03 21:28:23 +04:00
2015-03-03 17:37:17 +03:00
int dev_get_size ( struct device * dev , uint64_t * size )
2005-05-03 21:28:23 +04:00
{
2009-01-10 05:43:51 +03:00
if ( ! dev )
return 0 ;
2005-05-03 21:28:23 +04:00
if ( ( dev - > flags & DEV_REGULAR ) )
return _dev_get_size_file ( dev , size ) ;
2017-07-19 17:16:12 +03:00
return _dev_get_size_dev ( dev , size ) ;
2005-05-03 21:28:23 +04:00
}
2009-05-20 15:09:49 +04:00
int dev_get_read_ahead ( struct device * dev , uint32_t * read_ahead )
{
if ( ! dev )
return 0 ;
if ( dev - > flags & DEV_REGULAR ) {
* read_ahead = 0 ;
return 1 ;
}
return _dev_read_ahead_dev ( dev , read_ahead ) ;
}
2011-04-13 01:59:01 +04:00
int dev_discard_blocks ( struct device * dev , uint64_t offset_bytes , uint64_t size_bytes )
{
if ( ! dev )
return 0 ;
if ( dev - > flags & DEV_REGULAR )
return 1 ;
return _dev_discard_blocks ( dev , offset_bytes , size_bytes ) ;
}
2003-07-05 02:34:56 +04:00
void dev_flush ( struct device * dev )
2002-08-14 18:58:00 +04:00
{
2003-07-05 02:34:56 +04:00
if ( ! ( dev - > flags & DEV_REGULAR ) & & ioctl ( dev - > fd , BLKFLSBUF , 0 ) > = 0 )
2003-04-28 20:20:39 +04:00
return ;
2003-07-05 02:34:56 +04:00
if ( fsync ( dev - > fd ) > = 0 )
2003-04-28 20:20:39 +04:00
return ;
sync ( ) ;
2002-06-25 18:02:28 +04:00
}
2003-07-05 02:34:56 +04:00
int dev_open_flags ( struct device * dev , int flags , int direct , int quiet )
2001-11-14 13:01:52 +03:00
{
2002-01-23 21:55:01 +03:00
struct stat buf ;
2003-07-05 02:34:56 +04:00
const char * name ;
2005-10-04 01:10:41 +04:00
int need_excl = 0 , need_rw = 0 ;
if ( ( flags & O_ACCMODE ) = = O_RDWR )
need_rw = 1 ;
if ( ( flags & O_EXCL ) )
need_excl = 1 ;
2002-01-25 02:16:19 +03:00
2003-07-05 02:34:56 +04:00
if ( dev - > fd > = 0 ) {
2005-10-04 01:10:41 +04:00
if ( ( ( dev - > flags & DEV_OPENED_RW ) | | ! need_rw ) & &
( ( dev - > flags & DEV_OPENED_EXCL ) | | ! need_excl ) ) {
2004-12-13 00:47:14 +03:00
dev - > open_count + + ;
return 1 ;
}
2017-12-12 20:56:58 +03:00
if ( dev - > open_count & & ! need_excl )
2017-11-13 17:43:32 +03:00
log_debug_devs ( " %s: Already opened read-only. Upgrading "
2013-01-08 02:30:29 +04:00
" to read-write. " , dev_name ( dev ) ) ;
2017-12-12 20:56:58 +03:00
/* dev_close_immediate will decrement this */
dev - > open_count + + ;
2004-12-21 23:23:16 +03:00
2018-10-15 17:06:35 +03:00
if ( ! dev_close_immediate ( dev ) )
return_0 ;
2013-04-19 23:16:08 +04:00
// FIXME: dev with DEV_ALLOCED is released
// but code is referencing it
2002-01-25 02:16:19 +03:00
}
2001-11-14 13:01:52 +03:00
2011-02-18 17:16:11 +03:00
if ( critical_section ( ) )
2010-04-01 18:30:51 +04:00
/* FIXME Make this log_error */
log_verbose ( " dev_open(%s) called while suspended " ,
2013-01-08 02:30:29 +04:00
dev_name ( dev ) ) ;
2003-07-05 02:34:56 +04:00
2011-11-30 14:30:33 +04:00
if ( ! ( name = dev_name_confirmed ( dev , quiet ) ) )
2008-01-30 16:19:47 +03:00
return_0 ;
2001-11-14 13:01:52 +03:00
2003-11-06 20:14:06 +03:00
# ifdef O_DIRECT_SUPPORT
2005-04-07 16:17:46 +04:00
if ( direct ) {
if ( ! ( dev - > flags & DEV_O_DIRECT_TESTED ) )
dev - > flags | = DEV_O_DIRECT ;
if ( ( dev - > flags & DEV_O_DIRECT ) )
flags | = O_DIRECT ;
}
2003-11-06 20:14:06 +03:00
# endif
2003-07-05 02:34:56 +04:00
2004-09-15 02:23:23 +04:00
# ifdef O_NOATIME
/* Don't update atime on device inodes */
2016-05-12 03:05:52 +03:00
if ( ! ( dev - > flags & DEV_REGULAR ) & & ! ( dev - > flags & DEV_NOT_O_NOATIME ) )
2004-09-15 02:23:23 +04:00
flags | = O_NOATIME ;
# endif
2003-07-05 02:34:56 +04:00
if ( ( dev - > fd = open ( name , flags , 0777 ) ) < 0 ) {
2016-05-12 03:05:52 +03:00
# ifdef O_NOATIME
if ( ( errno = = EPERM ) & & ( flags & O_NOATIME ) ) {
flags & = ~ O_NOATIME ;
dev - > flags | = DEV_NOT_O_NOATIME ;
if ( ( dev - > fd = open ( name , flags , 0777 ) ) > = 0 ) {
log_debug_devs ( " %s: Not using O_NOATIME " , name ) ;
goto opened ;
}
}
# endif
2005-04-07 16:17:46 +04:00
# ifdef O_DIRECT_SUPPORT
if ( direct & & ! ( dev - > flags & DEV_O_DIRECT_TESTED ) ) {
flags & = ~ O_DIRECT ;
if ( ( dev - > fd = open ( name , flags , 0777 ) ) > = 0 ) {
dev - > flags & = ~ DEV_O_DIRECT ;
2013-01-08 02:30:29 +04:00
log_debug_devs ( " %s: Not using O_DIRECT " , name ) ;
2005-04-07 16:17:46 +04:00
goto opened ;
}
}
# endif
2005-03-04 00:54:35 +03:00
if ( quiet )
log_sys_debug ( " open " , name ) ;
else
log_sys_error ( " open " , name ) ;
2016-03-17 15:45:14 +03:00
dev - > flags | = DEV_OPEN_FAILURE ;
2001-11-14 13:01:52 +03:00
return 0 ;
}
2005-04-07 16:17:46 +04:00
# ifdef O_DIRECT_SUPPORT
2005-04-07 16:25:33 +04:00
opened :
2005-04-07 16:17:46 +04:00
if ( direct )
dev - > flags | = DEV_O_DIRECT_TESTED ;
# endif
2005-04-07 16:25:33 +04:00
dev - > open_count + + ;
2005-10-04 01:10:41 +04:00
if ( need_rw )
2004-12-10 19:01:35 +03:00
dev - > flags | = DEV_OPENED_RW ;
else
dev - > flags & = ~ DEV_OPENED_RW ;
2003-07-05 02:34:56 +04:00
2005-10-04 01:10:41 +04:00
if ( need_excl )
dev - > flags | = DEV_OPENED_EXCL ;
else
dev - > flags & = ~ DEV_OPENED_EXCL ;
2003-07-05 02:34:56 +04:00
if ( ! ( dev - > flags & DEV_REGULAR ) & &
( ( fstat ( dev - > fd , & buf ) < 0 ) | | ( buf . st_rdev ! = dev - > dev ) ) ) {
2002-01-23 21:55:01 +03:00
log_error ( " %s: fstat failed: Has device name changed? " , name ) ;
2018-10-15 17:06:35 +03:00
if ( ! dev_close_immediate ( dev ) )
stack ;
2002-01-23 21:55:01 +03:00
return 0 ;
}
2003-11-06 20:14:06 +03:00
# ifndef O_DIRECT_SUPPORT
2003-07-05 02:34:56 +04:00
if ( ! ( dev - > flags & DEV_REGULAR ) )
dev_flush ( dev ) ;
# endif
2004-12-10 19:01:35 +03:00
if ( ( flags & O_CREAT ) & & ! ( flags & O_TRUNC ) )
2003-07-05 02:34:56 +04:00
dev - > end = lseek ( dev - > fd , ( off_t ) 0 , SEEK_END ) ;
2013-01-08 02:30:29 +04:00
log_debug_devs ( " Opened %s %s%s%s " , dev_name ( dev ) ,
dev - > flags & DEV_OPENED_RW ? " RW " : " RO " ,
dev - > flags & DEV_OPENED_EXCL ? " O_EXCL " : " " ,
dev - > flags & DEV_O_DIRECT ? " O_DIRECT " : " " ) ;
2002-04-24 22:20:51 +04:00
2016-03-17 15:45:14 +03:00
dev - > flags & = ~ DEV_OPEN_FAILURE ;
2001-11-14 13:01:52 +03:00
return 1 ;
}
2003-07-05 02:34:56 +04:00
int dev_open_quiet ( struct device * dev )
{
2011-05-28 13:48:14 +04:00
return dev_open_flags ( dev , O_RDWR , 1 , 1 ) ;
2003-07-05 02:34:56 +04:00
}
int dev_open ( struct device * dev )
{
2011-05-28 13:48:14 +04:00
return dev_open_flags ( dev , O_RDWR , 1 , 0 ) ;
2003-07-05 02:34:56 +04:00
}
2011-05-24 17:36:57 +04:00
int dev_open_readonly ( struct device * dev )
{
return dev_open_flags ( dev , O_RDONLY , 1 , 0 ) ;
}
int dev_open_readonly_buffered ( struct device * dev )
{
return dev_open_flags ( dev , O_RDONLY , 0 , 0 ) ;
}
int dev_open_readonly_quiet ( struct device * dev )
{
return dev_open_flags ( dev , O_RDONLY , 1 , 1 ) ;
}
2003-07-05 02:34:56 +04:00
static void _close ( struct device * dev )
{
if ( close ( dev - > fd ) )
2020-09-30 00:48:45 +03:00
log_sys_debug ( " close " , dev_name ( dev ) ) ;
2003-07-05 02:34:56 +04:00
dev - > fd = - 1 ;
2013-01-08 02:30:29 +04:00
log_debug_devs ( " Closed %s " , dev_name ( dev ) ) ;
2003-07-05 02:34:56 +04:00
2015-08-17 14:57:01 +03:00
if ( dev - > flags & DEV_ALLOCED )
dev_destroy_file ( dev ) ;
2003-07-05 02:34:56 +04:00
}
2003-11-14 20:55:39 +03:00
static int _dev_close ( struct device * dev , int immediate )
2001-11-14 13:01:52 +03:00
{
if ( dev - > fd < 0 ) {
2001-11-14 16:52:38 +03:00
log_error ( " Attempt to close device '%s' "
" which is not open. " , dev_name ( dev ) ) ;
2001-11-14 13:01:52 +03:00
return 0 ;
}
2003-11-06 20:14:06 +03:00
2004-12-21 23:23:16 +03:00
if ( dev - > open_count > 0 )
dev - > open_count - - ;
2005-11-23 19:07:40 +03:00
if ( immediate & & dev - > open_count )
2013-01-08 02:30:29 +04:00
log_debug_devs ( " %s: Immediate close attempt while still referenced " ,
dev_name ( dev ) ) ;
2005-10-04 01:10:41 +04:00
2018-05-11 22:28:46 +03:00
if ( immediate | | ( dev - > open_count < 1 ) )
2003-07-05 02:34:56 +04:00
_close ( dev ) ;
2001-11-14 13:01:52 +03:00
return 1 ;
}
2003-11-14 20:55:39 +03:00
int dev_close ( struct device * dev )
{
return _dev_close ( dev , 0 ) ;
}
int dev_close_immediate ( struct device * dev )
{
return _dev_close ( dev , 1 ) ;
}