char *disk2serial(
disk_t *dp)
{
int s;
static char str[NUM_STR_SIZE];
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].dp == dp) {
g_snprintf(str, sizeof(str), "%02d-%05ld", s, stable[s].gen);
return str;
}
}
/* find unused serial number */
for(s = 0; s < MAX_SERIAL; s++)
if(stable[s].gen == 0 && stable[s].dp == NULL)
break;
if(s >= MAX_SERIAL) {
g_printf(_("driver: error time %s bug: out of serial numbers\n"),
walltime_str(curclock()));
s = 0;
}
stable[s].gen = generation++;
stable[s].dp = dp;
g_snprintf(str, sizeof(str), "%02d-%05ld", s, stable[s].gen);
return str;
}
times_t
stopclock(void)
{
GTimeVal diff;
diff = curclock();
clock_running = 0;
return diff;
}
void
check_unfree_serial(void)
{
int s;
/* find used serial number */
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].gen != 0 || stable[s].dp != NULL) {
g_printf(_("driver: error time %s bug: serial in use: %02d-%05ld\n"),
walltime_str(curclock()), s, stable[s].gen);
}
}
}
void
free_serial_dp(
disk_t *dp)
{
int s;
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].dp == dp) {
stable[s].gen = 0;
stable[s].dp = NULL;
return;
}
}
g_printf(_("driver: error time %s serial not found for disk %s\n"),
walltime_str(curclock()), dp->name);
}
cmd_t
getresult(
int fd,
int show,
int *result_argc,
char ***result_argv)
{
cmd_t t;
char *line;
if((line = areads(fd)) == NULL) {
if(errno) {
error(_("reading result from %s: %s"), childstr(fd), strerror(errno));
/*NOTREACHED*/
}
*result_argv = NULL;
*result_argc = 0; /* EOF */
} else {
*result_argv = split_quoted_strings(line);
*result_argc = g_strv_length(*result_argv);
}
if(show) {
g_printf(_("driver: result time %s from %s:"),
walltime_str(curclock()),
childstr(fd));
if(line) {
g_printf(" %s", line);
putchar('\n');
} else {
g_printf(" (eof)\n");
}
fflush(stdout);
}
amfree(line);
if(*result_argc < 1) return BOGUS;
for(t = (cmd_t)(BOGUS+1); t < LAST_TOK; t++)
if(strcmp((*result_argv)[0], cmdstr[t]) == 0) return t;
return BOGUS;
}
disk_t *
serial2disk(
char *str)
{
int rc, s;
long gen;
rc = sscanf(str, "%d-%ld", &s, &gen);
if(rc != 2) {
error(_("error [serial2disk \"%s\" parse error]"), str);
/*NOTREACHED*/
} else if (s < 0 || s >= MAX_SERIAL) {
error(_("error [serial out of range 0..%d: %d]"), MAX_SERIAL, s);
/*NOTREACHED*/
}
if(gen != stable[s].gen)
g_printf(_("driver: serial2disk error time %s serial gen mismatch %s\n"),
walltime_str(curclock()), str);
return stable[s].dp;
}
void
free_serial(
char *str)
{
int rc, s;
long gen;
rc = sscanf(str, _("%d-%ld"), &s, &gen);
if(!(rc == 2 && s >= 0 && s < MAX_SERIAL)) {
/* nuke self to get core dump for Brett */
g_fprintf(stderr, _("driver: free_serial: str \"%s\" rc %d s %d\n"),
str, rc, s);
fflush(stderr);
abort();
}
if(gen != stable[s].gen)
g_printf(_("driver: free_serial error time %s serial gen mismatch %s\n"),
walltime_str(curclock()),str);
stable[s].gen = 0;
stable[s].dp = NULL;
}
int
chunker_cmd(
chunker_t *chunker,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char chunksize[NUM_STR_SIZE];
char use[NUM_STR_SIZE];
char *o;
int activehd=0;
assignedhd_t **h=NULL;
char *features;
char *qname;
char *qdest;
switch(cmd) {
case START:
cmdline = g_strjoin(NULL, cmdstr[cmd], " ", mesg, "\n", NULL);
break;
case PORT_WRITE:
if(dp && sched(dp) && sched(dp)->holdp) {
h = sched(dp)->holdp;
activehd = sched(dp)->activehd;
}
if (dp && h) {
qname = quote_string(dp->name);
qdest = quote_string(sched(dp)->destname);
h[activehd]->disk->allocated_dumpers++;
g_snprintf(number, sizeof(number), "%d", sched(dp)->level);
g_snprintf(chunksize, sizeof(chunksize), "%lld",
(long long)holdingdisk_get_chunksize(h[0]->disk->hdisk));
g_snprintf(use, sizeof(use), "%lld",
(long long)h[0]->reserved);
features = am_feature_to_string(dp->host->features);
o = optionstr(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", features,
" ", qname,
" ", number,
" ", mesg, /* datestamp */
" ", chunksize,
" ", dp->program,
" ", use,
" |", o,
"\n", NULL);
amfree(features);
amfree(o);
amfree(qdest);
amfree(qname);
} else {
error(_("%s command without disk and holding disk.\n"),
cmdstr[cmd]);
/*NOTREACHED*/
}
break;
case CONTINUE:
if(dp && sched(dp) && sched(dp)->holdp) {
h = sched(dp)->holdp;
activehd = sched(dp)->activehd;
}
if(dp && h) {
qname = quote_string(dp->name);
qdest = quote_string(h[activehd]->destname);
h[activehd]->disk->allocated_dumpers++;
g_snprintf(chunksize, sizeof(chunksize), "%lld",
(long long)holdingdisk_get_chunksize(h[activehd]->disk->hdisk));
g_snprintf(use, sizeof(use), "%lld",
(long long)(h[activehd]->reserved - h[activehd]->used));
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", chunksize,
" ", use,
"\n", NULL );
amfree(qdest);
amfree(qname);
} else {
cmdline = g_strconcat(cmdstr[cmd], "\n", NULL);
}
break;
case QUIT:
cmdline = g_strjoin(NULL, cmdstr[cmd], "\n", NULL);
break;
case ABORT:
{
char *q = quote_string(mesg);
cmdline = g_strjoin(NULL, cmdstr[cmd], " ", q, "\n", NULL);
amfree(q);
}
break;
case DONE:
case FAILED:
if( dp ) {
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
"\n", NULL);
} else {
cmdline = g_strjoin(NULL, cmdstr[cmd], "\n", NULL);
}
break;
default:
error(_("Don't know how to send %s command to chunker"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), chunker->name, cmdline);
fflush(stdout);
if (full_write(chunker->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), chunker->name, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if (cmd == QUIT) aclose(chunker->fd);
amfree(cmdline);
return 1;
}
int
dumper_cmd(
dumper_t *dumper,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline;
char *qmesg;
switch(cmd) {
case START:
cmdline = g_strdup_printf("%s %s\n", cmdstr[cmd], mesg);
break;
case PORT_DUMP: {
application_t *application = NULL;
GPtrArray *array;
GString *strbuf;
gchar **args;
am_feature_t *features;
char *device, *plugin;
char *tmp;
if (!dp)
error("PORT-DUMP without disk pointer\n");
array = g_ptr_array_new();
features = dp->host->features;
device = (dp->device) ? dp->device : "NODEVICE";
if (dp->application != NULL) {
application = lookup_application(dp->application);
g_assert(application != NULL);
}
g_ptr_array_add(array, g_strdup(cmdstr[cmd]));
g_ptr_array_add(array, g_strdup(disk2serial(dp)));
g_ptr_array_add(array, g_strdup_printf("%d", dumper->output_port));
g_ptr_array_add(array, g_strdup(dp->host->hostname));
g_ptr_array_add(array, am_feature_to_string(features));
g_ptr_array_add(array, quote_string(dp->name));
g_ptr_array_add(array, quote_string(device));
g_ptr_array_add(array, g_strdup_printf("%d", sched(dp)->level));
g_ptr_array_add(array, g_strdup(sched(dp)->dumpdate));
/*
* Build the last argument
*/
strbuf = g_string_new("|");
if (am_has_feature(features, fe_req_xml)) {
char *qtmp;
tmp = xml_optionstr(dp, 1);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
tmp = xml_dumptype_properties(dp);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
if (application) {
tmp = xml_application(dp, application, features);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
}
} else {
tmp = optionstr(dp);
g_string_append(strbuf, tmp);
g_free(tmp);
}
g_string_append_c(strbuf, '\n');
g_assert(dp->program != NULL);
if (g_str_equal(dp->program, "APPLICATION")) {
g_assert(application != NULL);
plugin = application_get_plugin(application);
} else {
plugin = dp->program;
}
g_ptr_array_add(array, quote_string(plugin));
g_ptr_array_add(array, quote_string(dp->amandad_path));
g_ptr_array_add(array, quote_string(dp->client_username));
g_ptr_array_add(array, quote_string(dp->client_port));
g_ptr_array_add(array, quote_string(dp->ssh_keys));
g_ptr_array_add(array, g_strdup(dp->auth));
g_ptr_array_add(array, g_strdup(data_path_to_string(dp->data_path)));
g_ptr_array_add(array, g_strdup(dp->dataport_list));
g_ptr_array_add(array, g_strdup_printf("%d", dp->max_warnings));
g_ptr_array_add(array, g_string_free(strbuf, FALSE));
g_ptr_array_add(array, NULL);
args = (gchar **)g_ptr_array_free(array, FALSE);
cmdline = g_strjoinv(" ", args);
g_strfreev(args);
break;
}
case QUIT:
case ABORT:
qmesg = quote_string(mesg);
cmdline = g_strdup_printf("%s %s\n", cmdstr[cmd], qmesg);
amfree(qmesg);
break;
default:
error("Don't know how to send %s command to dumper", cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
if(dumper->down) {
g_printf(_("driver: send-cmd time %s ignored to down dumper %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
} else {
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
fflush(stdout);
if (full_write(dumper->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), dumper->name, strerror(errno));
fflush(stdout);
g_free(cmdline);
return 0;
}
if (cmd == QUIT) aclose(dumper->fd);
}
g_free(cmdline);
return 1;
}
int
taper_cmd(
cmd_t cmd,
void *ptr,
char *destname,
int level,
char *datestamp)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char orig_kb[NUM_STR_SIZE];
char *data_path;
disk_t *dp;
char *qname;
char *qdest;
char *q;
char *splitargs;
uintmax_t origsize;
switch(cmd) {
case START_TAPER:
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", destname,
" ", datestamp,
"\n", NULL);
break;
case CLOSE_VOLUME:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
"\n", NULL);
break;
case FILE_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
qdest = quote_string(destname);
g_snprintf(number, sizeof(number), "%d", level);
if (sched(dp)->origsize >= 0)
origsize = sched(dp)->origsize;
else
origsize = 0;
g_snprintf(orig_kb, sizeof(orig_kb), "%ju", origsize);
splitargs = taper_splitting_args(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitargs,
orig_kb,
"\n", NULL);
amfree(splitargs);
amfree(qdest);
amfree(qname);
break;
case PORT_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
g_snprintf(number, sizeof(number), "%d", level);
data_path = data_path_to_string(dp->data_path);
/*
If we haven't been given a place to buffer split dumps to disk,
make the argument something besides and empty string so's taper
won't get confused
*/
splitargs = taper_splitting_args(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitargs,
data_path,
"\n", NULL);
amfree(splitargs);
amfree(qname);
break;
case DONE: /* handle */
dp = (disk_t *) ptr;
if (sched(dp)->origsize >= 0)
origsize = sched(dp)->origsize;
else
origsize = 0;
g_snprintf(number, sizeof(number), "%ju", origsize);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", number,
"\n", NULL);
break;
case FAILED: /* handle */
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case NO_NEW_TAPE:
dp = (disk_t *) ptr;
q = quote_string(destname); /* reason why no new tape */
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", q,
"\n", NULL);
amfree(q);
break;
case NEW_TAPE:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case START_SCAN:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case TAKE_SCRIBE_FROM:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", destname, /* name of worker */
"\n", NULL);
break;
case QUIT:
cmdline = g_strconcat(cmdstr[cmd], "\n", NULL);
break;
default:
error(_("Don't know how to send %s command to taper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to taper: %s"),
walltime_str(curclock()), cmdline);
fflush(stdout);
if ((full_write(taper_fd, cmdline, strlen(cmdline))) < strlen(cmdline)) {
g_printf(_("writing taper command '%s' failed: %s\n"),
cmdline, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if(cmd == QUIT) aclose(taper_fd);
amfree(cmdline);
return 1;
}
static void
amgtar_estimate(
application_argument_t *argument)
{
char *incrname = NULL;
GPtrArray *argv_ptr;
char *cmd = NULL;
int nullfd = -1;
int pipefd = -1;
FILE *dumpout = NULL;
off_t size = -1;
char line[32768];
char *errmsg = NULL;
char *qerrmsg = NULL;
char *qdisk;
amwait_t wait_status;
int tarpid;
amregex_t *rp;
times_t start_time;
int level;
GSList *levels;
if (!argument->level) {
fprintf(stderr, "ERROR No level argument\n");
error(_("No level argument"));
}
if (!argument->dle.disk) {
fprintf(stderr, "ERROR No disk argument\n");
error(_("No disk argument"));
}
if (!argument->dle.device) {
fprintf(stderr, "ERROR No device argument\n");
error(_("No device argument"));
}
qdisk = quote_string(argument->dle.disk);
if (argument->calcsize) {
char *dirname;
char *file_exclude;
char *file_include;
int nb_exclude;
int nb_include;
if (gnutar_directory) {
dirname = gnutar_directory;
} else {
dirname = amname_to_dirname(argument->dle.device);
}
amgtar_build_exinclude(&argument->dle, 1,
&nb_exclude, &file_exclude,
&nb_include, &file_include);
run_calcsize(argument->config, "GNUTAR", argument->dle.disk, dirname,
argument->level, file_exclude, file_include);
return;
}
if (!gnutar_path) {
errmsg = vstrallocf(_("GNUTAR-PATH not defined"));
goto common_error;
}
if (!gnutar_listdir) {
errmsg = vstrallocf(_("GNUTAR-LISTDIR not defined"));
goto common_error;
}
for (levels = argument->level; levels != NULL; levels = levels->next) {
level = GPOINTER_TO_INT(levels->data);
incrname = amgtar_get_incrname(argument, level);
cmd = stralloc(gnutar_path);
argv_ptr = amgtar_build_argv(argument, incrname, CMD_ESTIMATE);
start_time = curclock();
if ((nullfd = open("/dev/null", O_RDWR)) == -1) {
errmsg = vstrallocf(_("Cannot access /dev/null : %s"),
strerror(errno));
goto common_exit;
}
tarpid = pipespawnv(cmd, STDERR_PIPE, 1,
&nullfd, &nullfd, &pipefd,
(char **)argv_ptr->pdata);
dumpout = fdopen(pipefd,"r");
if (!dumpout) {
error(_("Can't fdopen: %s"), strerror(errno));
/*NOTREACHED*/
}
size = (off_t)-1;
while (size < 0 && (fgets(line, sizeof(line), dumpout) != NULL)) {
if (line[strlen(line)-1] == '\n') /* remove trailling \n */
line[strlen(line)-1] = '\0';
if (line[0] == '\0')
continue;
dbprintf("%s\n", line);
/* check for size match */
/*@ignore@*/
for(rp = re_table; rp->regex != NULL; rp++) {
if(match(rp->regex, line)) {
if (rp->typ == DMP_SIZE) {
size = ((the_num(line, rp->field)*rp->scale+1023.0)/1024.0);
if(size < 0.0)
size = 1.0; /* found on NeXT -- sigh */
}
break;
}
}
/*@end@*/
}
while (fgets(line, sizeof(line), dumpout) != NULL) {
dbprintf("%s", line);
}
dbprintf(".....\n");
dbprintf(_("estimate time for %s level %d: %s\n"),
qdisk,
level,
walltime_str(timessub(curclock(), start_time)));
if(size == (off_t)-1) {
errmsg = vstrallocf(_("no size line match in %s output"), cmd);
dbprintf(_("%s for %s\n"), errmsg, qdisk);
dbprintf(".....\n");
} else if(size == (off_t)0 && argument->level == 0) {
dbprintf(_("possible %s problem -- is \"%s\" really empty?\n"),
cmd, argument->dle.disk);
dbprintf(".....\n");
}
dbprintf(_("estimate size for %s level %d: %lld KB\n"),
qdisk,
level,
(long long)size);
kill(-tarpid, SIGTERM);
dbprintf(_("waiting for %s \"%s\" child\n"), cmd, qdisk);
waitpid(tarpid, &wait_status, 0);
if (WIFSIGNALED(wait_status)) {
errmsg = vstrallocf(_("%s terminated with signal %d: see %s"),
cmd, WTERMSIG(wait_status), dbfn());
} else if (WIFEXITED(wait_status)) {
if (exit_value[WEXITSTATUS(wait_status)] == 1) {
errmsg = vstrallocf(_("%s exited with status %d: see %s"),
cmd, WEXITSTATUS(wait_status), dbfn());
} else {
/* Normal exit */
}
} else {
errmsg = vstrallocf(_("%s got bad exit: see %s"),
cmd, dbfn());
}
dbprintf(_("after %s %s wait\n"), cmd, qdisk);
common_exit:
if (errmsg) {
dbprintf("%s", errmsg);
fprintf(stdout, "ERROR %s\n", errmsg);
}
if (incrname) {
unlink(incrname);
}
g_ptr_array_free_full(argv_ptr);
amfree(cmd);
aclose(nullfd);
afclose(dumpout);
fprintf(stdout, "%d %lld 1\n", level, (long long)size);
}
amfree(qdisk);
return;
common_error:
qerrmsg = quote_string(errmsg);
amfree(qdisk);
dbprintf("%s", errmsg);
fprintf(stdout, "ERROR %s\n", qerrmsg);
amfree(errmsg);
amfree(qerrmsg);
return;
}
int
dumper_cmd(
dumper_t *dumper,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char numberport[NUM_STR_SIZE];
char *o;
char *device;
char *features;
char *qname;
char *qmesg;
switch(cmd) {
case START:
cmdline = vstralloc(cmdstr[cmd], " ", mesg, "\n", NULL);
break;
case PORT_DUMP:
if(dp && dp->device) {
device = dp->device;
}
else {
device = "NODEVICE";
}
if (dp != NULL) {
application_t *application = NULL;
char *plugin;
char *qplugin;
char *qamandad_path;
char *qclient_username;
char *qclient_port;
char *qssh_keys;
if (dp->application != NULL) {
application = lookup_application(dp->application);
g_assert(application != NULL);
}
device = quote_string((dp->device) ? dp->device : "NODEVICE");
qname = quote_string(dp->name);
g_snprintf(number, SIZEOF(number), "%d", sched(dp)->level);
g_snprintf(numberport, SIZEOF(numberport), "%d", dumper->output_port);
features = am_feature_to_string(dp->host->features);
if (am_has_feature(dp->host->features, fe_req_xml)) {
o = xml_optionstr(dp, dp->host->features, NULL, 1);
if (application) {
char *xml_app;
xml_app = xml_application(dp, application,
dp->host->features);
vstrextend(&o, xml_app, NULL);
amfree(xml_app);
}
o = quote_string(o);
} else {
o = optionstr(dp, dp->host->features, NULL);
}
if ( o == NULL ) {
error(_("problem with option string, check the dumptype definition.\n"));
}
g_assert(dp->program);
if (0 == strcmp(dp->program, "APPLICATION")) {
g_assert(application != NULL);
plugin = application_get_plugin(application);
} else {
plugin = dp->program;
}
qplugin = quote_string(plugin);
qamandad_path = quote_string(dp->amandad_path);
qclient_username = quote_string(dp->client_username);
qclient_port = quote_string(dp->client_port);
qssh_keys = quote_string(dp->ssh_keys);
dbprintf("security_driver %s\n", dp->auth);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", numberport,
" ", dp->host->hostname,
" ", features,
" ", qname,
" ", device,
" ", number,
" ", sched(dp)->dumpdate,
" ", qplugin,
" ", qamandad_path,
" ", qclient_username,
" ", qclient_port,
" ", qssh_keys,
" ", dp->auth,
" ", data_path_to_string(dp->data_path),
" |", o,
"\n", NULL);
amfree(qplugin);
amfree(qamandad_path);
amfree(qclient_username);
amfree(qclient_port);
amfree(qssh_keys);
amfree(features);
amfree(o);
amfree(qname);
amfree(device);
} else {
error(_("PORT-DUMP without disk pointer\n"));
/*NOTREACHED*/
}
break;
case QUIT:
case ABORT:
qmesg = quote_string(mesg);
cmdline = vstralloc(cmdstr[cmd], " ", qmesg, "\n", NULL );
amfree(qmesg);
break;
default:
error(_("Don't know how to send %s command to dumper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
if(dumper->down) {
g_printf(_("driver: send-cmd time %s ignored to down dumper %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
} else {
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
fflush(stdout);
if (full_write(dumper->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), dumper->name, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if (cmd == QUIT) aclose(dumper->fd);
}
amfree(cmdline);
return 1;
}
int
taper_cmd(
cmd_t cmd,
void *ptr,
char *destname,
int level,
char *datestamp)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char splitsize[NUM_STR_SIZE];
char fallback_splitsize[NUM_STR_SIZE];
char *diskbuffer = NULL;
disk_t *dp;
char *qname;
char *qdest;
char *q;
switch(cmd) {
case START_TAPER:
cmdline = vstralloc(cmdstr[cmd], " ", (char *)ptr, "\n", NULL);
break;
case FILE_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
qdest = quote_string(destname);
g_snprintf(number, SIZEOF(number), "%d", level);
g_snprintf(splitsize, SIZEOF(splitsize), "%lld",
(long long)dp->tape_splitsize * 1024);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitsize,
"\n", NULL);
amfree(qdest);
amfree(qname);
break;
case PORT_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
g_snprintf(number, SIZEOF(number), "%d", level);
/*
If we haven't been given a place to buffer split dumps to disk,
make the argument something besides and empty string so's taper
won't get confused
*/
if(!dp->split_diskbuffer || dp->split_diskbuffer[0] == '\0'){
diskbuffer = "NULL";
} else {
diskbuffer = dp->split_diskbuffer;
}
g_snprintf(splitsize, SIZEOF(splitsize), "%lld",
(long long)dp->tape_splitsize * 1024);
g_snprintf(fallback_splitsize, SIZEOF(fallback_splitsize), "%lld",
(long long)dp->fallback_splitsize * 1024);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitsize,
" ", diskbuffer,
" ", fallback_splitsize,
" ", data_path_to_string(dp->data_path),
"\n", NULL);
amfree(qname);
break;
case DONE: /* handle */
case FAILED: /* handle */
dp = (disk_t *) ptr;
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
"\n", NULL);
break;
case NO_NEW_TAPE:
q = quote_string((char *)ptr);
cmdline = vstralloc(cmdstr[cmd],
" ", q,
"\n", NULL);
amfree(q);
break;
case NEW_TAPE:
case QUIT:
cmdline = stralloc2(cmdstr[cmd], "\n");
break;
default:
error(_("Don't know how to send %s command to taper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to taper: %s"),
walltime_str(curclock()), cmdline);
fflush(stdout);
if ((full_write(taper, cmdline, strlen(cmdline))) < strlen(cmdline)) {
g_printf(_("writing taper command '%s' failed: %s\n"),
cmdline, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if(cmd == QUIT) aclose(taper);
amfree(cmdline);
return 1;
}
