diff options
Diffstat (limited to 'testing/sg_take_snap.c')
| -rw-r--r-- | testing/sg_take_snap.c | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/testing/sg_take_snap.c b/testing/sg_take_snap.c new file mode 100644 index 00000000..c714a409 --- /dev/null +++ b/testing/sg_take_snap.c @@ -0,0 +1,225 @@ +/* A utility program originally written for the Linux OS SCSI subsystem. + * Copyright (C) 2021 D. Gilbert + * 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; either version 2, or (at your option) + * any later version. + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * This program is experimental. It allows the SG_CTL_FLAGM_SNAP_DEV + * variant of ioctl(SG_SET_GET_EXTENDED) to be called. This assumes + * a Linux sg driver whose version number > 4.00.30 . + */ + +#include <unistd.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <stdbool.h> +#include <string.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <getopt.h> + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifndef HAVE_LINUX_SG_V4_HDR +/* Kernel uapi header contain __user decorations on user space pointers + * to indicate they are unsafe in the kernel space. However glibc takes + * all those __user decorations out from headers in /usr/include/linux . + * So to stop compile errors when directly importing include/uapi/scsi/sg.h + * undef __user before doing that include. */ +#define __user + +/* Want to block the original sg.h header from also being included. That + * causes lots of multiple definition errors. This will only work if this + * header is included _before_ the original sg.h header. */ +#define _SCSI_GENERIC_H /* original kernel header guard */ +#define _SCSI_SG_H /* glibc header guard */ + +#include "uapi_sg.h" /* local copy of include/uapi/scsi/sg.h */ + +#else +#define __user +#endif /* end of: ifndef HAVE_LINUX_SG_V4_HDR */ + +#include "sg_lib.h" +#include "sg_pr2serr.h" + + +#define ME "sg_take_snap: " + +static const char * version_str = "1.01 20210403"; + +#define SG_TAKE_MAX_DEVS 16 + +static const char *dev_arr[SG_TAKE_MAX_DEVS]; +static int next_vacant_dev_idx = 0; + +static struct option long_options[] = { + {"clear", no_argument, 0, 'c'}, + {"help", no_argument, 0, 'h'}, + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {0, 0, 0, 0}, +}; + +static void +usage(void) +{ + pr2serr("Usage: sg_take_snap [--clear] [--help] [--verbose] [--version] " + "DEVICE*\n" + " where:\n" + " --clear|-c set 'clear_first' flag; otherwise appends\n" + " --help|-h print usage information then exit\n" + " --verbose|-v increase the level of verbosity\n" + " --version|-V print version number then exit\n\n" + "Use ioctl(SG_SET_GET_EXTENDED(SG_CTL_FLAGM_SNAP_DEV)) to take " + "snap .\nThe output is placed in /sys/kernel/debug/scsi_generic/" + "snapped and needs\nroot permissions to read. Requires a Linux " + "sg driver version > 4.00.30 .\nOne or more DEVICEs can be " + "given. Note: sending the ioctl to do this\ncreates some " + "'noise' in the output\n" + ); +} + + +int main(int argc, char * argv[]) +{ + bool clear_first = false; + int c, k, sg_fd, res; + int ret = 0; + int verbose = 0; + const char * device_name = NULL; + struct sg_extended_info sei; + struct sg_extended_info * seip; + + while (1) { + int option_index = 0; + + c = getopt_long(argc, argv, "chvV", long_options, &option_index); + if (c == -1) + break; + + switch (c) { + case 'c': + clear_first = true; + break; + case 'h': + usage(); + return 0; + case 'v': + ++verbose; + break; + case 'V': + pr2serr(ME "version: %s\n", version_str); + return 0; + default: + pr2serr("unrecognised option code 0x%x ??\n", c); + usage(); + return SG_LIB_SYNTAX_ERROR; + } + } + + if (optind < argc) { + for (; optind < argc; ++optind) { + if (next_vacant_dev_idx < SG_TAKE_MAX_DEVS) { + dev_arr[next_vacant_dev_idx] = argv[optind]; + ++next_vacant_dev_idx; + } else if (next_vacant_dev_idx == SG_TAKE_MAX_DEVS) { + pr2serr("Maximum of %d DEVICEs on command line\n", + next_vacant_dev_idx); + usage(); + return SG_LIB_SYNTAX_ERROR; + } else { + pr2serr("something is wrong ...\n"); + return SG_LIB_SYNTAX_ERROR; + } + } + } + if (NULL == dev_arr[0]) { + pr2serr("Need at least one DEVICE name. Use '--help' to see " + "usage.\n"); + return SG_LIB_SYNTAX_ERROR; + } + + for (k = 0; k < next_vacant_dev_idx; ++k) { + device_name = dev_arr[k]; + sg_fd = open(device_name, O_RDWR | O_NONBLOCK); + if (sg_fd < 0) { + int err = errno; + + ret = sg_convert_errno(err); + pr2serr(ME "open error: %s: ", device_name); + perror(""); + sg_fd = -1; + goto fini; + } + if (0 == k) { + int t; + + res = ioctl(sg_fd, SG_GET_VERSION_NUM, &t); + if ((res < 0) || (t < 30000)) { + pr2serr("sg driver prior to 3.0.00\n"); + ret = SG_LIB_FILE_ERROR; + goto fini; + } + if (verbose) { + pr2serr("sg driver version: %d.%02d.%02d\n", + t / 10000, (t % 10000) / 100, t % 100); + } + if (t < 40000) { + pr2serr("Warning: sg driver prior to 4.0.00\n"); + ret = SG_LIB_FILE_ERROR; + goto fini; + } else if (t < 40045) { + pr2serr("Warning: sg driver prior to 4.0.45\n"); + ret = SG_LIB_FILE_ERROR; + goto fini; + } + } + + seip = &sei; + memset(seip, 0, sizeof(*seip)); + seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS; + seip->sei_rd_mask |= SG_SEIM_CTL_FLAGS; + seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_SNAP_DEV; + if (clear_first) /* ... else 0 (due to memset) --> append */ + seip->ctl_flags |= SG_CTL_FLAGM_SNAP_DEV; + if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { + pr2serr("ioctl(SG_SET_GET_EXTENDED(SG_CTL_FLAGM_SNAP_DEV)), %s " + "failed errno=%d %s\n", device_name, errno, + strerror(errno)); + ret = SG_LIB_FILE_ERROR; + goto fini; + } + if (verbose) + pr2serr("ioctl(%s, SG_SET_GET_EXTENDED(SG_CTL_FLAGM_SNAP_DEV)) " + "ok\n", device_name); + res = close(sg_fd); + sg_fd = -1; + if (res < 0) { + pr2serr("close errno=%d on %s\n", errno, device_name); + ret = res; + goto fini; + } + } + +fini: + if (sg_fd >= 0) { + res = close(sg_fd); + if (res < 0) { + res = sg_convert_errno(errno); + perror(ME "close error"); + if (0 == ret) + ret = res; + } + } + return (ret >= 0) ? ret : SG_LIB_CAT_OTHER; +} |