mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 12:02:42 +01:00
617dee3488
my_init_atomic_write(): Detect all forms of SSD, in case multiple types of devices are installed in the same machine. This was broken in commited008a74cfand further in commit70684afef2. SAME_DEV(): Match block devices, ignoring partition numbers. Let us use stat() instead of lstat(), in case someone has a symbolic link in /dev. Instead of reporting errors with perror(), let us use fprintf(stderr) with the file name, the impact of the error, and the strerror(errno). Because this code is specific to Linux, we may depend on the GNU libc/uClibc/musl extension %m for strerror(errno).
446 lines
12 KiB
C
446 lines
12 KiB
C
/* Copyright (c) 2016, 2021, MariaDB Corporation.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include "mysys_priv.h"
|
|
|
|
my_bool my_may_have_atomic_write= IF_WIN(1,0);
|
|
|
|
#ifdef __linux__
|
|
|
|
my_bool has_shannon_atomic_write= 0, has_fusion_io_atomic_write= 0,
|
|
has_sfx_atomic_write= 0;
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
/* Linux seems to allow up to 15 partitions per block device.
|
|
Partition number 0 is the whole block device. */
|
|
# define SAME_DEV(fs_dev, blk_dev) \
|
|
(fs_dev == blk_dev) || ((fs_dev & ~15U) == blk_dev)
|
|
|
|
/***********************************************************************
|
|
FUSION_IO
|
|
************************************************************************/
|
|
|
|
/** FusionIO atomic write control info */
|
|
#define DFS_IOCTL_ATOMIC_WRITE_SET _IOW(0x95, 2, uint)
|
|
|
|
|
|
/**
|
|
Check if the system has a funsion_io card
|
|
@return TRUE Card exists
|
|
*/
|
|
|
|
static my_bool test_if_fusion_io_card_exists()
|
|
{
|
|
/* Fusion card requires fallocate to exists */
|
|
#ifndef HAVE_POSIX_FALLOCATE
|
|
return 0;
|
|
#else
|
|
return (access("/dev/fcta", F_OK)) == 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
Check if a file is on a Fusion_IO device and that it supports atomic_write
|
|
@param[in] file OS file handle
|
|
@param[in] page_size page size
|
|
@return TRUE Atomic write supported
|
|
*/
|
|
|
|
static my_bool fusion_io_has_atomic_write(File file, int page_size)
|
|
{
|
|
int atomic= 1;
|
|
if (page_size <= 32768 &&
|
|
ioctl(file, DFS_IOCTL_ATOMIC_WRITE_SET, &atomic) != -1)
|
|
return(TRUE);
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
SHANNON
|
|
************************************************************************/
|
|
|
|
#define SHANNON_IOMAGIC 'x'
|
|
#define SHANNON_IOCQATOMIC_SIZE _IO(SHANNON_IOMAGIC, 22)
|
|
|
|
#define SHANNON_MAX_DEVICES 32
|
|
#define SHANNON_NO_ATOMIC_SIZE_YET -2
|
|
|
|
struct shannon_dev
|
|
{
|
|
char dev_name[32];
|
|
dev_t st_dev;
|
|
int atomic_size;
|
|
};
|
|
|
|
|
|
static struct shannon_dev shannon_devices[SHANNON_MAX_DEVICES+1];
|
|
|
|
/**
|
|
Check if the system has a Shannon card
|
|
If card exists, record device numbers to allow us to later check if
|
|
a given file is on this device.
|
|
@return TRUE Card exists
|
|
*/
|
|
|
|
static my_bool test_if_shannon_card_exists()
|
|
{
|
|
uint shannon_found_devices= 0;
|
|
char dev_part;
|
|
uint dev_no;
|
|
|
|
if (access("/dev/scta", F_OK) < 0)
|
|
return 0;
|
|
|
|
/*
|
|
The Shannon devices are /dev/dfX, where X can be from a-z.
|
|
We have to check all of them as some may be missing if the user
|
|
removed one with the U.2 interface.
|
|
*/
|
|
|
|
for (dev_part= 'a' ; dev_part < 'z' ; dev_part++)
|
|
{
|
|
char path[32];
|
|
struct stat stat_buff;
|
|
|
|
sprintf(path, "/dev/df%c", dev_part);
|
|
#ifdef TEST_SHANNON
|
|
if (stat(path, &stat_buff) < 0)
|
|
{
|
|
printf("%s(): stat %s failed.\n", __func__, path);
|
|
break;
|
|
}
|
|
#endif
|
|
shannon_devices[shannon_found_devices].st_dev= stat_buff.st_rdev;
|
|
sprintf(shannon_devices[shannon_found_devices].dev_name, "/dev/sct%c",
|
|
dev_part);
|
|
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): i=%d, stat_buff.st_dev=0x%lx, stat_buff.st_rdev=0x%lx, st_rdev=0x%lx, dev_name=%s\n",
|
|
__func__,
|
|
shannon_found_devices,
|
|
(ulong) stat_buff.st_dev,
|
|
(ulong) stat_buff.st_rdev,
|
|
(ulong) shannon_devices[shannon_found_devices].st_dev,
|
|
shannon_devices[shannon_found_devices].dev_name);
|
|
#endif
|
|
|
|
/*
|
|
The atomic size will be checked on first access. This is needed
|
|
as a normal user can't open the /dev/scta file
|
|
*/
|
|
shannon_devices[shannon_found_devices].atomic_size=
|
|
SHANNON_NO_ATOMIC_SIZE_YET;
|
|
if (++shannon_found_devices== SHANNON_MAX_DEVICES)
|
|
goto end;
|
|
|
|
for (dev_no= 1 ; dev_no < 9 ; dev_no++)
|
|
{
|
|
sprintf(path, "/dev/df%c%d", dev_part, dev_no);
|
|
if (stat(path, &stat_buff) < 0)
|
|
break;
|
|
|
|
shannon_devices[shannon_found_devices].st_dev= stat_buff.st_rdev;
|
|
sprintf(shannon_devices[shannon_found_devices].dev_name, "/dev/sct%c%d",
|
|
dev_part, dev_no);
|
|
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): i=%d, st_dev=0x%lx, st_rdev=0x%lx, dev_name=%s\n",
|
|
__func__,
|
|
shannon_found_devices,
|
|
(ulong) stat_buff.st_dev,
|
|
(ulong) shannon_devices[shannon_found_devices].st_dev,
|
|
shannon_devices[shannon_found_devices].dev_name);
|
|
#endif
|
|
|
|
/*
|
|
The atomic size will be checked on first access. This is needed
|
|
as a normal user can't open the /dev/scta file
|
|
*/
|
|
shannon_devices[shannon_found_devices].atomic_size=
|
|
SHANNON_NO_ATOMIC_SIZE_YET;
|
|
if (++shannon_found_devices == SHANNON_MAX_DEVICES)
|
|
goto end;
|
|
}
|
|
}
|
|
end:
|
|
shannon_devices[shannon_found_devices].st_dev= 0;
|
|
return shannon_found_devices > 0;
|
|
}
|
|
|
|
|
|
static my_bool shannon_dev_has_atomic_write(struct shannon_dev *dev,
|
|
int page_size)
|
|
{
|
|
#ifdef TEST_SHANNON
|
|
printf("%s: enter: page_size=%d, atomic_size=%d, dev_name=%s\n",
|
|
__func__,
|
|
page_size,
|
|
dev->atomic_size,
|
|
dev->dev_name);
|
|
#endif
|
|
if (dev->atomic_size == SHANNON_NO_ATOMIC_SIZE_YET)
|
|
{
|
|
int fd= open(dev->dev_name, 0);
|
|
if (fd < 0)
|
|
{
|
|
fprintf(stderr, "Unable to determine if atomic writes are supported:"
|
|
" open(\"%s\"): %m\n", dev->dev_name);
|
|
dev->atomic_size= 0; /* Don't try again */
|
|
return FALSE;
|
|
}
|
|
dev->atomic_size= ioctl(fd, SHANNON_IOCQATOMIC_SIZE);
|
|
close(fd);
|
|
}
|
|
|
|
#ifdef TEST_SHANNON
|
|
printf("%s: exit: page_size=%d, atomic_size=%d, dev_name=%s\n",
|
|
__func__,
|
|
page_size,
|
|
dev->atomic_size,
|
|
dev->dev_name);
|
|
#endif
|
|
return (page_size <= dev->atomic_size);
|
|
}
|
|
|
|
|
|
/**
|
|
Check if a file is on a Shannon device and that it supports atomic_write
|
|
@param[in] file OS file handle
|
|
@param[in] page_size page size
|
|
@return TRUE Atomic write supported
|
|
|
|
@notes
|
|
This is called only at first open of a file. In this case it's doesn't
|
|
matter so much that we loop over all cards.
|
|
We update the atomic size on first access.
|
|
*/
|
|
|
|
static my_bool shannon_has_atomic_write(File file, int page_size)
|
|
{
|
|
struct shannon_dev *dev;
|
|
struct stat stat_buff;
|
|
|
|
if (fstat(file, &stat_buff) < 0)
|
|
{
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): fstat failed\n", __func__);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): st_dev=0x%lx, st_rdev=0x%lx\n", __func__,
|
|
(ulong) stat_buff.st_dev, (ulong) stat_buff.st_rdev);
|
|
#endif
|
|
|
|
for (dev= shannon_devices ; dev->st_dev; dev++)
|
|
{
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): st_rdev=0x%lx\n", __func__, (ulong) dev->st_dev);
|
|
#endif
|
|
if (SAME_DEV(stat_buff.st_dev, dev->st_dev))
|
|
return shannon_dev_has_atomic_write(dev, page_size);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
ScaleFlux
|
|
************************************************************************/
|
|
|
|
#define SFX_GET_ATOMIC_SIZE _IO('N', 0x244)
|
|
#define SFX_MAX_DEVICES 32
|
|
#define SFX_NO_ATOMIC_SIZE_YET -2
|
|
|
|
struct sfx_dev
|
|
{
|
|
char dev_name[32];
|
|
dev_t st_dev;
|
|
int atomic_size;
|
|
};
|
|
|
|
static struct sfx_dev sfx_devices[SFX_MAX_DEVICES + 1];
|
|
|
|
/**
|
|
Check if the system has a ScaleFlux card
|
|
If card exists, record device numbers to allow us to later check if
|
|
a given file is on this device.
|
|
@return TRUE Card exists
|
|
*/
|
|
|
|
static my_bool test_if_sfx_card_exists()
|
|
{
|
|
uint sfx_found_devices = 0;
|
|
uint dev_num;
|
|
|
|
for (dev_num = 0; dev_num < SFX_MAX_DEVICES; dev_num++)
|
|
{
|
|
struct stat stat_buff;
|
|
|
|
sprintf(sfx_devices[sfx_found_devices].dev_name, "/dev/sfdv%dn1",
|
|
dev_num);
|
|
if (stat(sfx_devices[sfx_found_devices].dev_name, &stat_buff) < 0)
|
|
break;
|
|
|
|
sfx_devices[sfx_found_devices].st_dev= stat_buff.st_rdev;
|
|
/*
|
|
The atomic size will be checked on first access. This is needed
|
|
as a normal user can't open the /dev/sfdvXn1 file
|
|
*/
|
|
sfx_devices[sfx_found_devices].atomic_size = SFX_NO_ATOMIC_SIZE_YET;
|
|
if (++sfx_found_devices == SFX_MAX_DEVICES)
|
|
goto end;
|
|
}
|
|
end:
|
|
sfx_devices[sfx_found_devices].st_dev= 0;
|
|
return sfx_found_devices > 0;
|
|
}
|
|
|
|
static my_bool sfx_dev_has_atomic_write(struct sfx_dev *dev,
|
|
int page_size)
|
|
{
|
|
if (dev->atomic_size == SFX_NO_ATOMIC_SIZE_YET)
|
|
{
|
|
int fd= open(dev->dev_name, 0);
|
|
if (fd < 0)
|
|
{
|
|
fprintf(stderr, "Unable to determine if atomic writes are supported:"
|
|
" open(\"%s\"): %m\n", dev->dev_name);
|
|
dev->atomic_size= 0; /* Don't try again */
|
|
}
|
|
else
|
|
{
|
|
dev->atomic_size= ioctl(fd, SFX_GET_ATOMIC_SIZE);
|
|
close(fd);
|
|
}
|
|
}
|
|
|
|
return (page_size <= dev->atomic_size);
|
|
}
|
|
|
|
|
|
/**
|
|
Check if a file is on a ScaleFlux device and that it supports atomic_write
|
|
@param[in] file OS file handle
|
|
@param[in] page_size page size
|
|
@return TRUE Atomic write supported
|
|
|
|
@notes
|
|
This is called only at first open of a file. In this case it's doesn't
|
|
matter so much that we loop over all cards.
|
|
We update the atomic size on first access.
|
|
*/
|
|
|
|
static my_bool sfx_has_atomic_write(File file, int page_size)
|
|
{
|
|
struct sfx_dev *dev;
|
|
struct stat stat_buff;
|
|
|
|
if (fstat(file, &stat_buff) == 0)
|
|
for (dev= sfx_devices; dev->st_dev; dev++)
|
|
if (SAME_DEV(stat_buff.st_dev, dev->st_dev))
|
|
return sfx_dev_has_atomic_write(dev, page_size);
|
|
return 0;
|
|
}
|
|
/***********************************************************************
|
|
Generic atomic write code
|
|
************************************************************************/
|
|
|
|
/*
|
|
Initialize automic write sub systems.
|
|
Checks if we have any devices that supports atomic write
|
|
*/
|
|
|
|
void my_init_atomic_write(void)
|
|
{
|
|
has_shannon_atomic_write= test_if_shannon_card_exists();
|
|
has_fusion_io_atomic_write= test_if_fusion_io_card_exists();
|
|
has_sfx_atomic_write= test_if_sfx_card_exists();
|
|
|
|
my_may_have_atomic_write= has_shannon_atomic_write ||
|
|
has_fusion_io_atomic_write || has_sfx_atomic_write;
|
|
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): has_shannon_atomic_write=%d, my_may_have_atomic_write=%d\n",
|
|
__func__,
|
|
has_shannon_atomic_write,
|
|
my_may_have_atomic_write);
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
Check if a file supports atomic write
|
|
|
|
@return FALSE No atomic write support
|
|
TRUE File supports atomic write
|
|
*/
|
|
|
|
my_bool my_test_if_atomic_write(File handle, int page_size)
|
|
{
|
|
#ifdef TEST_SHANNON
|
|
printf("%s(): has_shannon_atomic_write=%d, my_may_have_atomic_write=%d\n",
|
|
__func__,
|
|
has_shannon_atomic_write,
|
|
my_may_have_atomic_write);
|
|
#endif
|
|
if (!my_may_have_atomic_write)
|
|
return 0;
|
|
|
|
if (has_shannon_atomic_write &&
|
|
shannon_has_atomic_write(handle, page_size))
|
|
return 1;
|
|
|
|
if (has_fusion_io_atomic_write &&
|
|
fusion_io_has_atomic_write(handle, page_size))
|
|
return 1;
|
|
|
|
if (has_sfx_atomic_write &&
|
|
sfx_has_atomic_write(handle, page_size))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef TEST_SHANNON
|
|
int main()
|
|
{
|
|
int fd, ret;
|
|
|
|
my_init_atomic_write();
|
|
fd= open("/u01/1.file", O_RDWR);
|
|
ret= my_test_if_atomic_write(fd, 4096);
|
|
if (ret)
|
|
printf("support atomic_write\n");
|
|
else
|
|
printf("do not support atomic_write\n");
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#else /* __linux__ */
|
|
|
|
/* Dummy functions to provide the interfaces for other systems */
|
|
|
|
void my_init_atomic_write(void)
|
|
{
|
|
}
|
|
#endif /* __linux__ */
|