uint8_t ssc_erase(struct scsi_cmd *cmd)
{
struct priv_lu_ssc *lu_priv;
uint8_t *sam_stat;
lu_priv = cmd->lu->lu_private;
sam_stat = &cmd->dbuf_p->sam_stat;
MHVTL_DBG(1, "Erasing (%ld) **", (long)cmd->dbuf_p->serialNo);
current_state = MHVTL_STATE_ERASE;
if (!lu_priv->pm->check_restrictions(cmd))
return SAM_STAT_CHECK_CONDITION;
if (c_pos->blk_number != 0) {
MHVTL_LOG("Not at BOT.. Can't erase unless at BOT");
mkSenseBuf(NOT_READY, E_INVALID_FIELD_IN_CDB, sam_stat);
return SAM_STAT_CHECK_CONDITION;
}
if (OK_to_write)
format_tape(sam_stat);
else {
MHVTL_LOG("Attempt to erase Write-protected media");
mkSenseBuf(NOT_READY, E_MEDIUM_OVERWRITE_ATTEMPTED, sam_stat);
return SAM_STAT_CHECK_CONDITION;
}
return SAM_STAT_GOOD;
}
uint8_t ssc_format_media(struct scsi_cmd *cmd)
{
struct lu_phy_attr *lu;
struct priv_lu_ssc *lu_priv;
lu = cmd->lu;
lu_priv = lu->lu_private;
MHVTL_DBG(1, "Format Medium (%ld) **", (long)cmd->dbuf_p->serialNo);
if (!lu_priv->pm->check_restrictions(cmd))
return SAM_STAT_CHECK_CONDITION;
if (c_pos->blk_number != 0) {
MHVTL_DBG(2, "Not at beginning **");
mkSenseBuf(ILLEGAL_REQUEST, E_POSITION_PAST_BOM,
&cmd->dbuf_p->sam_stat);
return SAM_STAT_CHECK_CONDITION;
}
format_tape(&cmd->dbuf_p->sam_stat);
return SAM_STAT_GOOD;
}
/* Operation */
int main(int argc, char **argv)
{
struct ltfs_volume *newvol;
struct other_format_opts opt;
int ret, log_level, syslog_level, i, cmd_args_len;
char *lang, *cmd_args;
const char *config_file = NULL;
void *message_handle;
char cmd_input = 0;
int fuse_argc = argc;
char **fuse_argv = calloc(fuse_argc, sizeof(char *));
if (! fuse_argv) {
return MKLTFS_OPERATIONAL_ERROR;
}
for (i = 0; i < fuse_argc; ++i) {
fuse_argv[i] = strdup(argv[i]);
if (! fuse_argv[i]) {
return MKLTFS_OPERATIONAL_ERROR;
}
}
struct fuse_args args = FUSE_ARGS_INIT(fuse_argc, fuse_argv);
#ifdef HP_mingw_BUILD
(void) lang;
#endif /* HP_mingw_BUILD */
#ifndef HP_mingw_BUILD
/* Check for LANG variable and set it to en_US.UTF-8 if it is unset. */
lang = getenv("LANG");
if (! lang) {
fprintf(stderr, "LTFS9015W Setting the locale to 'en_US.UTF-8'. If this is wrong, please set the LANG environment variable before starting mkltfs.\n");
ret = setenv("LANG", "en_US.UTF-8", 1);
if (ret) {
fprintf(stderr, "LTFS9016E Cannot set the LANG environment variable\n");
return MKLTFS_OPERATIONAL_ERROR;
}
}
#endif /* HP_mingw_BUILD */
/* Start up libltfs with the default logging level. */
#ifndef mingw_PLATFORM
openlog("mkltfs", LOG_PID, LOG_USER);
#endif
ret = ltfs_init(LTFS_INFO, true, false);
if (ret < 0) {
ltfsmsg(LTFS_ERR, "10000E", ret);
return MKLTFS_OPERATIONAL_ERROR;
}
/* Setup signal handler to terminate cleanly */
ret = ltfs_set_signal_handlers();
if (ret < 0) {
ltfsmsg(LTFS_ERR, "10013E");
return MKLTFS_OPERATIONAL_ERROR;
}
/* Register messages with libltfs */
ret = ltfsprintf_load_plugin("bin_mkltfs", bin_mkltfs_dat, &message_handle);
if (ret < 0) {
ltfsmsg(LTFS_ERR, "10012E", ret);
return MKLTFS_OPERATIONAL_ERROR;
}
/* Set up empty format options and load the configuration file. */
memset(&opt, 0, sizeof(struct other_format_opts));
opt.enable_compression = true;
opt.allow_update = true;
opt.unformat = false;
opt.force = false;
opt.quiet = false;
opt.blocksize = LTFS_DEFAULT_BLOCKSIZE;
opt.long_wipe = false;
opt.interactive = false;
/* Check for a config file path given on the command line */
while (true) {
int option_index = 0;
int c = getopt_long(argc, argv, short_options, long_options, &option_index);
if (c == -1)
break;
if (c == 'i') {
config_file = strdup(optarg);
break;
}
}
/* Load configuration file */
ret = config_file_load(config_file, &opt.config);
if (ret < 0) {
ltfsmsg(LTFS_ERR, "10008E", ret);
return MKLTFS_OPERATIONAL_ERROR;
}
/* Parse all command line arguments */
optind = 1;
int num_of_o = 0;
while (true) {
int option_index = 0;
int c = getopt_long(argc, argv, short_options, long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'i':
break;
case 'e':
free(opt.backend_path);
opt.backend_path = strdup(optarg);
break;
case 'd':
opt.devname = strdup(optarg);
break;
case 'b':
opt.blocksize = atoi(optarg);
break;
case 's':
opt.barcode = strdup(optarg);
break;
case 'n':
opt.volume_name = strdup(optarg);
break;
case 'r':
opt.filterrules = strdup(optarg);
break;
case '-':
opt.kmi_backend_name = strdup(optarg);
break;
case 'c':
opt.enable_compression = false;
break;
case 'o':
/* ignore -o here to parse them by fuse */
++num_of_o;
break;
case ' ':
opt.allow_update = false;
break;
case 'k':
opt.keep_capacity = true;
break;
case 'w':
opt.unformat = true;
break;
case 'f':
opt.force = true;
break;
case '+':
opt.unformat = true;
opt.long_wipe = true;
break;
case 'q':
opt.quiet = true;
break;
case 't':
opt.trace = true;
break;
case '!':
opt.syslogtrace = true;
break;
case 'x':
opt.fulltrace = true;
break;
case 'g':
opt.interactive = true;
break;
case 'h':
show_usage(argv[0], opt.config, false);
return 0;
case 'p':
show_usage(argv[0], opt.config, true);
return 0;
case 'V':
ltfsresult("15059I", "mkltfs", PACKAGE_VERSION);
ltfsresult("15059I", "LTFS Format Specification", LTFS_INDEX_VERSION_STR);
return 0;
case '?':
default:
show_usage(argv[0], opt.config, false);
return MKLTFS_USAGE_SYNTAX_ERROR;
}
}
if (optind + num_of_o < argc) {
show_usage(argv[0], opt.config, false);
return MKLTFS_USAGE_SYNTAX_ERROR;
}
/* Pick up default backend if one wasn't specified before */
if (! opt.backend_path) {
const char *default_backend = config_file_get_default_plugin("driver", opt.config);
if (! default_backend) {
ltfsmsg(LTFS_ERR, "10009E");
return MKLTFS_OPERATIONAL_ERROR;
}
opt.backend_path = strdup(default_backend);
}
if (! opt.kmi_backend_name) {
const char *default_backend = config_file_get_default_plugin("kmi", opt.config);
if (default_backend)
opt.kmi_backend_name = strdup(default_backend);
else
opt.kmi_backend_name = strdup("none");
}
if (opt.kmi_backend_name && strcmp(opt.kmi_backend_name, "none") == 0) {
free(opt.kmi_backend_name);
opt.kmi_backend_name = NULL;
}
/* Set the logging level */
if (opt.quiet && (opt.trace || opt.fulltrace)) {
ltfsmsg(LTFS_ERR, "9012E");
show_usage(argv[0], opt.config, false);
return 1;
} else if (opt.quiet) {
log_level = LTFS_WARN;
syslog_level = LTFS_NONE;
} else if (opt.trace) {
log_level = LTFS_DEBUG;
syslog_level = LTFS_NONE;
} else if (opt.syslogtrace)
log_level = syslog_level = LTFS_DEBUG;
else if (opt.fulltrace) {
log_level = LTFS_TRACE;
syslog_level = LTFS_DEBUG;
} else {
log_level = LTFS_INFO;
syslog_level = LTFS_NONE;
}
ltfs_set_log_level(log_level);
ltfs_set_syslog_level(syslog_level);
/* Starting mkltfs */
#ifdef GENERIC_OEM_BUILD
ltfsmsg(LTFS_INFO, "15000I", SOFTWARE_PRODUCT_NAME, PACKAGE_VERSION, log_level);
#else
ltfsmsg(LTFS_INFO, "15000I", LTFS_VENDOR_NAME SOFTWARE_PRODUCT_NAME, PACKAGE_VERSION, log_level);
#endif /* GENERIC_OEM_BUILD */
/* Show command line arguments */
for (i = 0, cmd_args_len = 0 ; i < argc; i++) {
cmd_args_len += strlen(argv[i]) + 1;
}
cmd_args = calloc(1, cmd_args_len + 1);
if (!cmd_args) {
/* Memory allocation failed */
ltfsmsg(LTFS_ERR, "10001E", "mkltfs (arguments)");
return MKLTFS_OPERATIONAL_ERROR;
}
strcat(cmd_args, argv[0]);
for (i = 1; i < argc; i++) {
strcat(cmd_args, " ");
strcat(cmd_args, argv[i]);
}
ltfsmsg(LTFS_INFO, "15041I", cmd_args);
free(cmd_args);
/* Show build time information */
ltfsmsg(LTFS_INFO, "15042I", BUILD_SYS_FOR);
ltfsmsg(LTFS_INFO, "15043I", BUILD_SYS_GCC);
/* Show run time information */
show_runtime_system_info();
ret = ltfs_fs_init();
if (ret)
return MKLTFS_OPERATIONAL_ERROR;
/* Actually mkltfs logic starts here */
ret = ltfs_volume_alloc("mkltfs", &newvol);
if (ret < 0) {
ltfsmsg(LTFS_ERR, "15001E");
return MKLTFS_OPERATIONAL_ERROR;
}
ret = ltfs_set_blocksize(opt.blocksize, newvol);
if (ret < 0) {
if (ret == -LTFS_SMALL_BLOCKSIZE)
ltfsmsg(LTFS_ERR, "15028E", LTFS_MIN_BLOCKSIZE);
show_usage(argv[0], opt.config, false);
return MKLTFS_OPERATIONAL_ERROR;
}
ltfs_set_compression(opt.enable_compression, newvol);
ret = ltfs_set_barcode(opt.barcode, newvol);
if (ret < 0) {
if (ret == -LTFS_BARCODE_LENGTH)
ltfsmsg(LTFS_ERR, "15029E");
else if (ret == -LTFS_BARCODE_INVALID)
ltfsmsg(LTFS_ERR, "15030E");
show_usage(argv[0], opt.config, false);
return MKLTFS_USAGE_SYNTAX_ERROR;
}
if (_mkltfs_validate_options(argv[0], newvol, &opt)) {
ltfsmsg(LTFS_ERR, "15002E");
show_usage(argv[0], opt.config, false);
return MKLTFS_USAGE_SYNTAX_ERROR;
}
ltfsmsg(LTFS_INFO, "15003I", opt.devname);
ltfsmsg(LTFS_INFO, "15004I", opt.blocksize);
ltfsmsg(LTFS_INFO, "15005I", opt.filterrules ? opt.filterrules : "None");
if (! opt.quiet)
fprintf(stderr, "\n");
/* Statutory Warning before format/unformat */
if (! opt.force && !opt.quiet && opt.interactive) {
ltfsmsg(LTFS_INFO, "15492I");
fflush(stdin);
scanf("%c", &cmd_input);
while (getchar() != '\n');
switch (cmd_input) {
case 'Y':
case 'y':
opt.force = true;
break;
default:
ltfsmsg(LTFS_INFO, "15493I");
ret = 1;
goto out_close;
}
}
if(opt.unformat)
ret = unformat_tape(newvol, &opt, &args);
else
ret = format_tape(newvol, &opt, &args);
out_close:
if (opt.backend_path)
free(opt.backend_path);
if (opt.kmi_backend_name)
free(opt.kmi_backend_name);
if (opt.devname)
free(opt.devname);
while (fuse_argc) {
free(fuse_argv[--fuse_argc]);
}
free(fuse_argv);
config_file_free(opt.config);
ltfsprintf_unload_plugin(message_handle);
ltfs_finish();
return ret;
}
