580 lines
16 KiB
C
580 lines
16 KiB
C
/*
|
|
*/
|
|
|
|
#include <libcbd.h>
|
|
|
|
#include <cbdutil.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
/*
|
|
* Parse argument into an unsigned 64-bit value.
|
|
*
|
|
* The following suffixes are recognized (case insensitive and
|
|
* always base two, as in LVM):
|
|
* b bytes
|
|
* s sectors
|
|
* k kilo (1024)
|
|
* m mega (1024^2)
|
|
* g giga (1024^3)
|
|
* t tera (1024^4)
|
|
* p peta (1024^5)
|
|
*
|
|
* If no suffix is given, bytes are assumed.
|
|
*/
|
|
static bool
|
|
parse_numeric_arg(const char* arg, uint64_t* val)
|
|
{
|
|
unsigned long ulval;
|
|
const char* end;
|
|
|
|
ulval = strtoul(arg, (char**)&end, 0);
|
|
if (ulval == ULONG_MAX || end == arg) {
|
|
return false;
|
|
}
|
|
*val = ulval;
|
|
switch (*end) {
|
|
case '\0':
|
|
case 'B':
|
|
case 'b':
|
|
/* No conversion */
|
|
break;
|
|
case 'S':
|
|
case 's':
|
|
*val <<= 9;
|
|
break;
|
|
case 'K':
|
|
case 'k':
|
|
*val <<= 10;
|
|
break;
|
|
case 'M':
|
|
case 'm':
|
|
*val <<= 20;
|
|
break;
|
|
case 'G':
|
|
case 'g':
|
|
*val <<= 30;
|
|
break;
|
|
case 'T':
|
|
case 't':
|
|
*val <<= 40;
|
|
break;
|
|
case 'P':
|
|
case 'p':
|
|
*val <<= 50;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
parse_boolean_arg(const char* arg, uint64_t* val)
|
|
{
|
|
if (!strcmp(arg, "1") ||
|
|
!strcasecmp(arg, "true") ||
|
|
!strcasecmp(arg, "on") ||
|
|
!strcasecmp(arg, "yes")) {
|
|
*val = 1;
|
|
return true;
|
|
}
|
|
else if (!strcmp(arg, "0") ||
|
|
!strcasecmp(arg, "false") ||
|
|
!strcasecmp(arg, "off") ||
|
|
!strcasecmp(arg, "no")) {
|
|
*val = 0;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
struct profile {
|
|
const char* name;
|
|
uint pblksize;
|
|
uint lblksize;
|
|
enum cbd_alg alg;
|
|
uint level;
|
|
};
|
|
static struct profile profiles[] = {
|
|
{ "performance", 1*1024, 4*1024, CBD_ALG_LZ4, 1 },
|
|
{ "mixed", 4*1024, 64*1024, CBD_ALG_LZ4, 3 },
|
|
{ "read-mostly", 4*1024, 64*1024, CBD_ALG_ZLIB, 6 },
|
|
{ "archive", 4*1024, 256*1024, CBD_ALG_ZLIB, 9 },
|
|
};
|
|
|
|
static bool
|
|
parse_profile(const char* name,
|
|
uint* pblksize, uint* lblksize,
|
|
enum cbd_alg* alg, uint* level)
|
|
{
|
|
uint n;
|
|
|
|
for (n = 0; n < ARRAY_SIZE(profiles); ++n) {
|
|
struct profile* profile = &profiles[n];
|
|
if (!strcmp(profile->name, name)) {
|
|
*pblksize = profile->pblksize;
|
|
*lblksize = profile->lblksize;
|
|
*alg = profile->alg;
|
|
*level = profile->level;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static uint
|
|
get_shift(uint val, uint base)
|
|
{
|
|
uint shift = 0;
|
|
|
|
while (val > base) {
|
|
++shift;
|
|
base *= 2;
|
|
}
|
|
|
|
return shift;
|
|
}
|
|
|
|
static const char* progname;
|
|
|
|
static void __attribute__((noreturn))
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "Usage: %s [-h] [-v] <command> [options] <device>\n"
|
|
"\n", progname);
|
|
fprintf(stderr, "Global arguments:\n"
|
|
" -h --help Show this help message and exit\n"
|
|
" -v --verbose Increase verbose level\n"
|
|
"\n");
|
|
fprintf(stderr, "Commands:\n"
|
|
" format [opts] <device> Create (format) a compressed device\n"
|
|
" -P --pbat-size Physical block allocation table size [1]\n"
|
|
" -S --pysical-size Physical size [device size]\n"
|
|
" -c --compress-factor Compression factor [2.0]\n"
|
|
" -l --logical-blksize Logical block size\n"
|
|
" -p --physical-blksize Physical block size\n"
|
|
" -s --size Logical size\n"
|
|
" -z --compress-alg Compression algorithm [lz4]\n"
|
|
" -Z --compress-level Compression level [1]\n"
|
|
" --detect-zeros Detect and free zero blocks at runtime\n"
|
|
" --profile Set -p -l -z -Z automatically\n"
|
|
" --full-init Fully init device (no lazy init)\n"
|
|
" Note:\n"
|
|
" -c and -s are different ways of specifying the compressed device size.\n"
|
|
" Only one may be used, not both.\n"
|
|
" Profiles:\n"
|
|
" performance: 1k pblk, 4k lblk, lz4 level 1\n"
|
|
" mixed: 4k pblk, 64k lblk, lz4 level 3\n"
|
|
" read-mostly: 4k pblk, 64k lblk, zlib level 6\n"
|
|
" archive: 4k pblk, 256k lblk, zlib level 9\n"
|
|
"\n"
|
|
" open [opts] <device> <name> Open an existing compressed device\n"
|
|
" -c --cache-pages Set cache pages\n"
|
|
" -s --sync Open in synchronous mode\n"
|
|
" create [opts] <device> <name> Alias for open\n"
|
|
" close [opts] <name> Close an opened compressed device\n"
|
|
" check [opts] <device> Check and repair a compressed device\n"
|
|
" -f --force Force check even if device seems clean\n"
|
|
" -F --full-check Do a full check, including verifying data\n"
|
|
" -n --assume-no Assume \"no\" no all questions\n"
|
|
" -y --assume-yes Assume \"yes\" to all questions\n"
|
|
" resize [opts] <device> Resize an existing compressed device\n"
|
|
" -s --size New logical size [use all]\n"
|
|
" stats [opts] <name> Show device statistics\n"
|
|
"\n");
|
|
exit(1);
|
|
}
|
|
|
|
static int
|
|
do_format(int argc, char** argv)
|
|
{
|
|
static const char short_opts[] = "P:S:c:l:p:s:z:Z:";
|
|
static const struct option long_opts[] = {
|
|
{ "pbat-size", required_argument, NULL, 'P' },
|
|
{ "physical-size", required_argument, NULL, 'S' },
|
|
{ "compress-factor", required_argument, NULL, 'c' },
|
|
{ "logical-blksize", required_argument, NULL, 'l' },
|
|
{ "physical-blksize", required_argument, NULL, 'p' },
|
|
{ "size", required_argument, NULL, 's' },
|
|
{ "compress-alg", required_argument, NULL, 'z' },
|
|
{ "compress-level", required_argument, NULL, 'Z' },
|
|
{ "detect-zeros", optional_argument, NULL, 0x1 },
|
|
{ "profile", required_argument, NULL, 0x2 },
|
|
{ "full-init", no_argument, NULL, 0x3 },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
char opt;
|
|
uint64_t optval;
|
|
uint64_t psize = 0;
|
|
uint64_t lsize = 0;
|
|
uint pblksize = PAGE_SIZE;
|
|
uint lblksize = 16 * PAGE_SIZE;
|
|
uint pbatsize = 1;
|
|
uint16_t flags = 0;
|
|
enum cbd_alg alg = CBD_ALG_LZ4;
|
|
uint level = 1;
|
|
bool full_init = false;
|
|
|
|
uint8_t pshift;
|
|
uint8_t lshift;
|
|
uint8_t pbatshift;
|
|
|
|
const char* dev;
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 'P':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
if (optval < 1) {
|
|
error("Size \"%s\" is not a valid pbat len\n", optarg);
|
|
}
|
|
pbatsize = optval;
|
|
break;
|
|
case 'S':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
psize = optval;
|
|
break;
|
|
case 'c':
|
|
error("Implement me!\n");
|
|
break;
|
|
case 'l':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
if (optval & (optval - 1)) {
|
|
error("Size \"%s\" is not a valid block size\n", optarg);
|
|
}
|
|
lblksize = optval;
|
|
break;
|
|
case 'p':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
if (optval & (optval - 1)) {
|
|
error("Size \"%s\" is not a valid block size\n", optarg);
|
|
}
|
|
pblksize = optval;
|
|
break;
|
|
case 's':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
lsize = optval;
|
|
break;
|
|
case 'z':
|
|
alg = CBD_ALG_NONE;
|
|
if (!strcmp(optarg, "lz4")) {
|
|
alg = CBD_ALG_LZ4;
|
|
}
|
|
if (!strcmp(optarg, "zlib")) {
|
|
alg = CBD_ALG_ZLIB;
|
|
}
|
|
if (alg == CBD_ALG_NONE) {
|
|
error("Invalid compression algorithm \"%s\"\n", optarg);
|
|
}
|
|
break;
|
|
case 'Z':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
if (optval < 1 || optval > 9) {
|
|
error("Compression level \"%s\" out of bounds\n", optarg);
|
|
}
|
|
level = optval;
|
|
break;
|
|
case 0x1:
|
|
optval = 1;
|
|
if (optarg) {
|
|
if (!parse_boolean_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
}
|
|
if (optval) {
|
|
flags |= CBD_FLAG_DETECT_ZEROS;
|
|
}
|
|
break;
|
|
case 0x2:
|
|
if (!parse_profile(optarg, &pblksize, &lblksize, &alg, &level)) {
|
|
error("Invalid profile \"%s\"\n", optarg);
|
|
}
|
|
break;
|
|
case 0x3:
|
|
full_init = true;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
pshift = get_shift(pblksize, SECTOR_SIZE);
|
|
if (pshift < PBLK_SHIFT_MIN || pshift > PBLK_SHIFT_MAX) {
|
|
error("Invalid physical block size %u\n", pblksize);
|
|
}
|
|
lshift = get_shift(lblksize, pblksize);
|
|
if (lshift < LBLK_SHIFT_MIN || lshift > LBLK_SHIFT_MAX) {
|
|
error("Invalid logical block size %u\n", lblksize);
|
|
}
|
|
pbatshift = get_shift(pbatsize, 1);
|
|
if (pbatshift < PBAT_SHIFT_MIN || pbatshift > PBAT_SHIFT_MAX) {
|
|
error("Invalid pbat len %u\n", pbatsize);
|
|
}
|
|
if (argc - optind != 1) {
|
|
usage();
|
|
}
|
|
dev = argv[optind++];
|
|
|
|
cbd_format(dev, flags, alg, level,
|
|
pshift, lshift, pbatshift, psize, lsize,
|
|
full_init);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_open(int argc, char** argv)
|
|
{
|
|
static const char short_opts[] = "c:s";
|
|
static const struct option long_opts[] = {
|
|
{ "cache-pages", required_argument, NULL, 'c' },
|
|
{ "sync", no_argument, NULL, 's' },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
char opt;
|
|
uint64_t optval;
|
|
uint64_t cache_pages = 0;
|
|
bool sync = false;
|
|
char dev[PATH_MAX];
|
|
const char* name;
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 'c':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
error("Failed to parse \"%s\"\n", optarg);
|
|
}
|
|
if (optval < 1) {
|
|
error("Size \"%s\" is not a valid cache size\n", optarg);
|
|
}
|
|
cache_pages = optval;
|
|
break;
|
|
case 's':
|
|
sync = true;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
if (argc - optind != 2) {
|
|
usage();
|
|
}
|
|
strcpy(dev, argv[optind]);
|
|
if (dev[0] != '/') {
|
|
sprintf(dev, "/dev/mapper/%s", argv[optind]);
|
|
}
|
|
++optind;
|
|
name = argv[optind++];
|
|
|
|
cbd_open(dev, name, cache_pages, sync);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_close(int argc, char** argv)
|
|
{
|
|
const char* dev;
|
|
|
|
if (argc != 2) {
|
|
usage();
|
|
}
|
|
dev = argv[1];
|
|
|
|
cbd_close(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_stats(int argc, char** argv)
|
|
{
|
|
const char* name;
|
|
struct cbd_stats stats;
|
|
|
|
if (argc != 2) {
|
|
usage();
|
|
}
|
|
name = argv[1];
|
|
|
|
cbd_stats(name, &stats);
|
|
printf("Stats:\n");
|
|
printf("pblk used: %lu\n", (unsigned long)stats.pblk_used);
|
|
printf("lblk used: %lu\n", (unsigned long)stats.lblk_used);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_check(int argc, char** argv)
|
|
{
|
|
static const char short_opts[] = "fFny";
|
|
static const struct option long_opts[] = {
|
|
{ "force", no_argument, NULL, 'f' },
|
|
{ "full-check", no_argument, NULL, 'F' },
|
|
{ "assume-no", no_argument, NULL, 'n' },
|
|
{ "assume-yes", no_argument, NULL, 'y' },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
char opt;
|
|
bool force = false;
|
|
bool full_check = false;
|
|
tristate_t auto_response = t_none;
|
|
|
|
const char* dev;
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 'f':
|
|
force = true;
|
|
break;
|
|
case 'F':
|
|
full_check = true;
|
|
break;
|
|
case 'n':
|
|
if (auto_response == t_true) {
|
|
fprintf(stderr, "Cannot specify both -y and -n\n");
|
|
usage();
|
|
}
|
|
auto_response = t_false;
|
|
break;
|
|
case 'y':
|
|
if (auto_response == t_false) {
|
|
fprintf(stderr, "Cannot specify both -y and -n\n");
|
|
usage();
|
|
}
|
|
auto_response = t_true;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
if (argc - optind != 1) {
|
|
usage();
|
|
}
|
|
dev = argv[optind++];
|
|
|
|
cbd_check(dev, force, auto_response, full_check);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_resize(int argc, char** argv)
|
|
{
|
|
static const char short_opts[] = "s:";
|
|
static const struct option long_opts[] = {
|
|
{ "size", required_argument, NULL, 's' },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
char opt;
|
|
uint64_t optval;
|
|
uint64_t lsize = 0;
|
|
|
|
char dev[PATH_MAX];
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 's':
|
|
if (!parse_numeric_arg(optarg, &optval)) {
|
|
fprintf(stderr, "Failed to parse \"%s\"\n", optarg);
|
|
usage();
|
|
}
|
|
lsize = optval;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
if (argc - optind != 1) {
|
|
usage();
|
|
}
|
|
strcpy(dev, argv[optind]);
|
|
if (dev[0] != '/') {
|
|
sprintf(dev, "/dev/mapper/%s", argv[optind]);
|
|
}
|
|
++optind;
|
|
|
|
cbd_resize(dev, lsize);
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct cmd_dispatch
|
|
{
|
|
const char* cmd;
|
|
int (*func)(int, char**);
|
|
};
|
|
|
|
static struct cmd_dispatch dispatch[] =
|
|
{
|
|
{ "format", do_format },
|
|
{ "open", do_open },
|
|
{ "create", do_open },
|
|
{ "close", do_close },
|
|
{ "stats", do_stats },
|
|
{ "check", do_check },
|
|
{ "resize", do_resize },
|
|
};
|
|
|
|
int
|
|
main(int argc, char** argv)
|
|
{
|
|
static const char short_opts[] = "+v";
|
|
static const struct option long_opts[] = {
|
|
{ "verbose", 0, NULL, 'v' },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
char opt;
|
|
|
|
const char* cmd;
|
|
uint n;
|
|
|
|
progname = argv[0];
|
|
|
|
/* Disable stdout buffering. */
|
|
setbuf(stdout, NULL);
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 'v':
|
|
++verbose_level;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
if (argc - optind < 1) {
|
|
usage();
|
|
}
|
|
cmd = argv[optind];
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
optind = 0;
|
|
for (n = 0; n < ARRAY_SIZE(dispatch); ++n) {
|
|
if (!strcmp(cmd, dispatch[n].cmd)) {
|
|
return dispatch[n].func(argc, argv);
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Unrecognized command \"%s\"\n", cmd);
|
|
usage();
|
|
/* NOTREACHED */
|
|
}
|