X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=server-src%2Fplanner.c;h=a36fc6cf9a6abe9fdc5a217d26d87bcb1fba3578;hb=94a044f90357edefa6f4ae9f0b1d5885b0e34aee;hp=5e44c577e734ae0d1e15aa783605352ebf9ad729;hpb=94c03cae686e4196a345d72452fda2a5203768ce;p=debian%2Famanda diff --git a/server-src/planner.c b/server-src/planner.c index 5e44c57..a36fc6c 100644 --- a/server-src/planner.c +++ b/server-src/planner.c @@ -24,7 +24,7 @@ * file named AUTHORS, in the root directory of this distribution. */ /* - * $Id: planner.c,v 1.180.2.1 2006/04/24 11:16:43 martinea Exp $ + * $Id: planner.c,v 1.206 2006/08/10 23:57:27 paddy_s Exp $ * * backup schedule planner for the Amanda backup system. */ @@ -43,6 +43,13 @@ #include "amfeatures.h" #include "server_util.h" #include "holding.h" +#include "timestamp.h" + +#define planner_debug(i,x) do { \ + if ((i) <= debug_planner) { \ + dbprintf(x); \ + } \ +} while (0) #define MAX_LEVELS 3 /* max# of estimates per filesys */ @@ -53,15 +60,16 @@ /* configuration file stuff */ -char *conf_tapetype; -am64_t conf_maxdumpsize; -int conf_runtapes; -int conf_dumpcycle; -int conf_runspercycle; -int conf_tapecycle; -int conf_etimeout; -int conf_reserve; -int conf_autoflush; +char * conf_tapetype; +off_t conf_maxdumpsize; +int conf_runtapes; +int conf_dumpcycle; +int conf_runspercycle; +int conf_tapecycle; +time_t conf_etimeout; +int conf_reserve; +int conf_autoflush; +int conf_usetimestamps; #define HOST_READY ((void *)0) /* must be 0 */ #define HOST_ACTIVE ((void *)1) @@ -77,11 +85,13 @@ typedef struct est_s { int got_estimate; int dump_priority; int dump_level; - long dump_size; + off_t dump_nsize; /* native size */ + off_t dump_csize; /* compressed size */ int degr_level; /* if dump_level == 0, what would be the inc level */ - long degr_size; + off_t degr_nsize; /* native degraded size */ + off_t degr_csize; /* compressed degraded size */ int last_level; - long last_lev0size; + off_t last_lev0size; int next_level0; int level_days; int promote; @@ -90,23 +100,24 @@ typedef struct est_s { char *errstr; int level[MAX_LEVELS]; char *dumpdate[MAX_LEVELS]; - long est_size[MAX_LEVELS]; + off_t est_size[MAX_LEVELS]; } est_t; #define est(dp) ((est_t *)(dp)->up) /* pestq = partial estimate */ disklist_t startq, waitq, pestq, estq, failq, schedq; -am64_t total_size; +off_t total_size; double total_lev0, balanced_size, balance_threshold; -am64_t tape_length, tape_mark; +off_t tape_length; +size_t tape_mark; tapetype_t *tape; -long tt_blocksize; -long tt_blocksize_kb; +size_t tt_blocksize; +size_t tt_blocksize_kb; int runs_per_cycle = 0; time_t today; -char *datestamp = NULL; +char *planner_timestamp = NULL; static am_feature_t *our_features = NULL; static char *our_feature_string = NULL; @@ -122,7 +133,8 @@ typedef struct bi_s { int deleted; /* 0=modified, 1=deleted */ disk_t *dp; /* The disk that was changed */ int level; /* The original level */ - long size; /* The original size */ + off_t nsize; /* The original native size */ + off_t csize; /* The original compressed size */ char *errstr; /* A message describing why this disk is here */ } bi_t; @@ -138,60 +150,76 @@ bilist_t biq; /* The BI queue itself */ * */ -static void setup_estimate P((disk_t *dp)); -static void get_estimates P((void)); -static void analyze_estimate P((disk_t *dp)); -static void handle_failed P((disk_t *dp)); -static void delay_dumps P((void)); -static int promote_highest_priority_incremental P((void)); -static int promote_hills P((void)); -static void output_scheduleline P((disk_t *dp)); -int main P((int, char **)); - -int main(argc, argv) -int argc; -char **argv; +static void setup_estimate(disk_t *dp); +static void get_estimates(void); +static void analyze_estimate(disk_t *dp); +static void handle_failed(disk_t *dp); +static void delay_dumps(void); +static int promote_highest_priority_incremental(void); +static int promote_hills(void); +static void output_scheduleline(disk_t *dp); +int main(int, char **); + +int +main( + int argc, + char ** argv) { disklist_t origq; disk_t *dp; int moved_one; - unsigned long malloc_hist_1, malloc_size_1; - unsigned long malloc_hist_2, malloc_size_2; - long initial_size; + int diskarg_offset; + off_t initial_size; int i; - char *conffile; char *conf_diskfile; char *conf_tapelist; char *conf_infofile; times_t section_start; + char *qname; + int nb_disk; + char *errstr = NULL; + config_overwrites_t *cfg_ovr = NULL; + char *cfg_opt = NULL; + + /* + * Configure program for internationalization: + * 1) Only set the message locale for now. + * 2) Set textdomain for all amanda related programs to "amanda" + * We don't want to be forced to support dozens of message catalogs. + */ + setlocale(LC_MESSAGES, "C"); + textdomain("amanda"); + + /* drop root privileges */ + if (!set_root_privs(0)) { + error(_("planner must be run setuid root")); + } safe_fd(-1, 0); - setvbuf(stderr, (char *)NULL, _IOLBF, 0); + set_pname("planner"); - if (argc > 1) { - config_name = stralloc(argv[1]); - config_dir = vstralloc(CONFIG_DIR, "/", config_name, "/", NULL); - } else { - char my_cwd[STR_SIZE]; + dbopen(DBG_SUBDIR_SERVER); - if (getcwd(my_cwd, sizeof(my_cwd)) == NULL) { - error("cannot determine current working directory"); - } - config_dir = stralloc2(my_cwd, "/"); - if ((config_name = strrchr(my_cwd, '/')) != NULL) { - config_name = stralloc(config_name + 1); - } - } + cfg_ovr = extract_commandline_config_overwrites(&argc, &argv); + + if (argc > 1) + cfg_opt = argv[1]; + + config_init(CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_USE_CWD | CONFIG_INIT_FATAL, + cfg_opt); + apply_config_overwrites(cfg_ovr); safe_cd(); - set_pname("planner"); + check_running_as(RUNNING_AS_DUMPUSER); + + dbrename(config_name, DBG_SUBDIR_SERVER); /* Don't die when child closes pipe */ signal(SIGPIPE, SIG_IGN); - malloc_size_1 = malloc_inuse(&malloc_hist_1); + setvbuf(stderr, (char *)NULL, (int)_IOLBF, 0); erroutput_type = (ERR_AMANDALOG|ERR_INTERACTIVE); set_logerror(logerror); @@ -201,87 +229,80 @@ char **argv; our_features = am_init_feature_set(); our_feature_string = am_feature_to_string(our_features); - fprintf(stderr, "%s: pid %ld executable %s version %s\n", + g_fprintf(stderr, _("%s: pid %ld executable %s version %s\n"), get_pname(), (long) getpid(), argv[0], version()); for (i = 0; version_info[i] != NULL; i++) - fprintf(stderr, "%s: %s", get_pname(), version_info[i]); + g_fprintf(stderr, _("%s: %s"), get_pname(), version_info[i]); + + diskarg_offset = 2; + if (argc > 3 && strcmp(argv[2], "--starttime") == 0) { + planner_timestamp = stralloc(argv[3]); + diskarg_offset += 2; + } + /* * 1. Networking Setup * - * Planner runs setuid to get a priviledged socket for BSD security. - * We get the socket right away as root, then setuid back to a normal - * user. If we are not using BSD security, planner is not installed - * setuid root. */ protocol_init(); - if(geteuid() == 0) { - uid_t ruid = getuid(); - setuid(0); - seteuid(ruid); - setgid(getgid()); - } - - /* - * From this point on we are running under our real uid, so we don't - * have to worry about opening security holes below. Make sure we - * are a valid user. - */ - - if(getpwuid(getuid()) == NULL) - error("can't get login name for my uid %ld", (long)getuid()); - /* * 2. Read in Configuration Information * * All the Amanda configuration files are loaded before we begin. */ - fprintf(stderr,"READING CONF FILES...\n"); + g_fprintf(stderr,_("READING CONF INFO...\n")); - conffile = stralloc2(config_dir, CONFFILE_NAME); - if(read_conffile(conffile)) { - error("errors processing config file \"%s\"", conffile); + conf_diskfile = config_dir_relative(getconf_str(CNF_DISKFILE)); + if (read_diskfile(conf_diskfile, &origq) < 0) { + error(_("could not load disklist \"%s\""), conf_diskfile); + /*NOTREACHED*/ } - amfree(conffile); - - conf_diskfile = getconf_str(CNF_DISKFILE); - if (*conf_diskfile == '/') { - conf_diskfile = stralloc(conf_diskfile); - } else { - conf_diskfile = stralloc2(config_dir, conf_diskfile); + if(origq.head == NULL) { + error(_("empty disklist \"%s\""), conf_diskfile); + /*NOTREACHED*/ } - if (read_diskfile(conf_diskfile, &origq) < 0) { - error("could not load disklist \"%s\"", conf_diskfile); + + errstr = match_disklist(&origq, argc-diskarg_offset, + argv+diskarg_offset); + if (errstr) { + g_fprintf(stderr,"%s",errstr); + amfree(errstr); } - match_disklist(&origq, argc-2, argv+2); + nb_disk = 0; for(dp = origq.head; dp != NULL; dp = dp->next) { - if(dp->todo) - log_add(L_DISK, "%s %s", dp->host->hostname, dp->name); + if(dp->todo) { + qname = quote_string(dp->name); + log_add(L_DISK, "%s %s", dp->host->hostname, qname); + amfree(qname); + nb_disk++; + } } - amfree(conf_diskfile); - conf_tapelist = getconf_str(CNF_TAPELIST); - if (*conf_tapelist == '/') { - conf_tapelist = stralloc(conf_tapelist); - } else { - conf_tapelist = stralloc2(config_dir, conf_tapelist); + if(nb_disk == 0) { + error(_("no DLE to backup")); + /*NOTREACHED*/ } + amfree(conf_diskfile); + + conf_tapelist = config_dir_relative(getconf_str(CNF_TAPELIST)); if(read_tapelist(conf_tapelist)) { - error("could not load tapelist \"%s\"", conf_tapelist); + error(_("could not load tapelist \"%s\""), conf_tapelist); + /*NOTREACHED*/ } amfree(conf_tapelist); - conf_infofile = getconf_str(CNF_INFOFILE); - if (*conf_infofile == '/') { - conf_infofile = stralloc(conf_infofile); - } else { - conf_infofile = stralloc2(config_dir, conf_infofile); - } + conf_infofile = config_dir_relative(getconf_str(CNF_INFOFILE)); if(open_infofile(conf_infofile)) { - error("could not open info db \"%s\"", conf_infofile); + error(_("could not open info db \"%s\""), conf_infofile); + /*NOTREACHED*/ + } + if (check_infofile(conf_infofile, &origq, &errstr) == -1) { + log_add(L_WARNING, "problem copying infofile: %s", errstr); + amfree(errstr); } amfree(conf_infofile); @@ -291,14 +312,27 @@ char **argv; conf_dumpcycle = getconf_int(CNF_DUMPCYCLE); conf_runspercycle = getconf_int(CNF_RUNSPERCYCLE); conf_tapecycle = getconf_int(CNF_TAPECYCLE); - conf_etimeout = getconf_int(CNF_ETIMEOUT); + conf_etimeout = (time_t)getconf_int(CNF_ETIMEOUT); conf_reserve = getconf_int(CNF_RESERVE); - conf_autoflush = getconf_int(CNF_AUTOFLUSH); + conf_autoflush = getconf_boolean(CNF_AUTOFLUSH); + conf_usetimestamps = getconf_boolean(CNF_USETIMESTAMPS); - amfree(datestamp); today = time(0); - datestamp = construct_datestamp(NULL); - log_add(L_START, "date %s", datestamp); + if (planner_timestamp) { + if (conf_usetimestamps == 0) { + planner_timestamp[8] = '\0'; + } + } else if(conf_usetimestamps == 0) { + planner_timestamp = get_datestamp_from_time(0); + } + else { + planner_timestamp = get_timestamp_from_time(0); + } + log_add(L_START, _("date %s"), planner_timestamp); + g_printf("DATE %s\n", planner_timestamp); + fflush(stdout); + g_fprintf(stderr, _("%s: timestamp %s\n"), + get_pname(), planner_timestamp); /* some initializations */ @@ -317,22 +351,22 @@ char **argv; * do some basic sanity checking */ if(conf_tapecycle <= runs_per_cycle) { - log_add(L_WARNING, "tapecycle (%d) <= runspercycle (%d)", + log_add(L_WARNING, _("tapecycle (%d) <= runspercycle (%d)"), conf_tapecycle, runs_per_cycle); } tape = lookup_tapetype(conf_tapetype); - if(conf_maxdumpsize > 0) { - tape_length = conf_maxdumpsize; + if(conf_maxdumpsize > (off_t)0) { + tape_length = (off_t)conf_maxdumpsize; } else { - tape_length = tape->length * conf_runtapes; + tape_length = tapetype_get_length(tape) * (off_t)conf_runtapes; } - tape_mark = tape->filemark; - tt_blocksize_kb = tape->blocksize; + tape_mark = (size_t)tapetype_get_filemark(tape); + tt_blocksize_kb = (size_t)tapetype_get_blocksize(tape); tt_blocksize = tt_blocksize_kb * 1024; - fprintf(stderr, "%s: time %s: startup took %s secs\n", + g_fprintf(stderr, _("%s: time %s: startup took %s secs\n"), get_pname(), walltime_str(curclock()), walltime_str(timessub(curclock(), section_start))); @@ -344,38 +378,51 @@ char **argv; * dump schedule. */ - fprintf(stderr,"\nSENDING FLUSHES...\n"); + g_fprintf(stderr,_("\nSENDING FLUSHES...\n")); if(conf_autoflush) { - dumpfile_t file; - sl_t *holding_list; - sle_t *holding_file; - holding_list = get_flush(NULL, NULL, 0, 0); - for(holding_file=holding_list->first; holding_file != NULL; + dumpfile_t file; + GSList *holding_list, *holding_file; + char *qdisk, *qhname; + + /* get *all* flushable files in holding */ + holding_list = holding_get_files_for_flush(NULL); + for(holding_file=holding_list; holding_file != NULL; holding_file = holding_file->next) { - get_dumpfile(holding_file->name, &file); - - log_add(L_DISK, "%s %s", file.name, file.disk); - fprintf(stderr, + holding_file_get_dumpfile((char *)holding_file->data, &file); + + if (holding_file_size((char *)holding_file->data, 1) <= 0) { + log_add(L_INFO, "%s: removing file with no data.", + (char *)holding_file->data); + holding_file_unlink((char *)holding_file->data); + continue; + } + + qdisk = quote_string(file.disk); + qhname = quote_string((char *)holding_file->data); + log_add(L_DISK, "%s %s", file.name, qdisk); + g_fprintf(stderr, "FLUSH %s %s %s %d %s\n", file.name, - file.disk, + qdisk, file.datestamp, file.dumplevel, - holding_file->name); - fprintf(stdout, + qhname); + g_fprintf(stdout, "FLUSH %s %s %s %d %s\n", file.name, - file.disk, + qdisk, file.datestamp, file.dumplevel, - holding_file->name); + qhname); + amfree(qdisk); + amfree(qhname); } - free_sl(holding_list); + g_slist_free_full(holding_list); holding_list = NULL; } - fprintf(stderr, "ENDFLUSH\n"); - fprintf(stdout, "ENDFLUSH\n"); + g_fprintf(stderr, _("ENDFLUSH\n")); + g_fprintf(stdout, _("ENDFLUSH\n")); fflush(stdout); /* @@ -386,7 +433,7 @@ char **argv; * based on the curinfo database. */ - fprintf(stderr,"\nSETTING UP FOR ESTIMATES...\n"); + g_fprintf(stderr,_("\nSETTING UP FOR ESTIMATES...\n")); section_start = curclock(); startq.head = startq.tail = NULL; @@ -397,7 +444,7 @@ char **argv; } } - fprintf(stderr, "%s: time %s: setting up estimates took %s secs\n", + g_fprintf(stderr, _("%s: time %s: setting up estimates took %s secs\n"), get_pname(), walltime_str(curclock()), walltime_str(timessub(curclock(), section_start))); @@ -412,7 +459,7 @@ char **argv; /* go out and get the dump estimates */ - fprintf(stderr,"\nGETTING ESTIMATES...\n"); + g_fprintf(stderr,_("\nGETTING ESTIMATES...\n")); section_start = curclock(); estq.head = estq.tail = NULL; @@ -422,7 +469,7 @@ char **argv; get_estimates(); - fprintf(stderr, "%s: time %s: getting estimates took %s secs\n", + g_fprintf(stderr, _("%s: time %s: getting estimates took %s secs\n"), get_pname(), walltime_str(curclock()), walltime_str(timessub(curclock(), section_start))); @@ -446,11 +493,11 @@ char **argv; * total expected size is accumulated as well. */ - fprintf(stderr,"\nANALYZING ESTIMATES...\n"); + g_fprintf(stderr,_("\nANALYZING ESTIMATES...\n")); section_start = curclock(); /* an empty tape still has a label and an endmark */ - total_size = (tt_blocksize_kb + tape_mark) * 2; + total_size = ((off_t)tt_blocksize_kb + (off_t)tape_mark) * (off_t)2; total_lev0 = 0.0; balanced_size = 0.0; @@ -466,11 +513,16 @@ char **argv; { disk_t *dp; - fprintf(stderr, "INITIAL SCHEDULE (size " AM64_FMT "):\n", total_size); + g_fprintf(stderr, _("INITIAL SCHEDULE (size %lld):\n"), + (long long)total_size); for(dp = schedq.head; dp != NULL; dp = dp->next) { - fprintf(stderr, " %s %s pri %d lev %d size %ld\n", - dp->host->hostname, dp->name, est(dp)->dump_priority, - est(dp)->dump_level, est(dp)->dump_size); + qname = quote_string(dp->name); + g_fprintf(stderr, _(" %s %s pri %d lev %d nsize %lld csize %lld\n"), + dp->host->hostname, qname, est(dp)->dump_priority, + est(dp)->dump_level, + (long long)est(dp)->dump_nsize, + (long long)est(dp)->dump_csize); + amfree(qname); } } @@ -487,17 +539,20 @@ char **argv; * until the dumps fit on the tape. */ - fprintf(stderr, - "\nDELAYING DUMPS IF NEEDED, total_size " AM64_FMT ", tape length " AM64_FMT " mark " AM64_FMT "\n", - total_size, tape_length, tape_mark); + g_fprintf(stderr, _("\nDELAYING DUMPS IF NEEDED, total_size %lld, tape length %lld mark %zu\n"), + (long long)total_size, + (long long)tape_length, + tape_mark); initial_size = total_size; delay_dumps(); /* XXX - why bother checking this? */ - if(empty(schedq) && total_size < initial_size) - error("cannot fit anything on tape, bailing out"); + if(empty(schedq) && total_size < initial_size) { + error(_("cannot fit anything on tape, bailing out")); + /*NOTREACHED*/ + } /* @@ -518,8 +573,8 @@ char **argv; * a big bump. */ - fprintf(stderr, - "\nPROMOTING DUMPS IF NEEDED, total_lev0 %1.0f, balanced_size %1.0f...\n", + g_fprintf(stderr, + _("\nPROMOTING DUMPS IF NEEDED, total_lev0 %1.0lf, balanced_size %1.0lf...\n"), total_lev0, balanced_size); balance_threshold = balanced_size * PROMOTE_THRESHOLD; @@ -529,7 +584,7 @@ char **argv; moved_one = promote_hills(); - fprintf(stderr, "%s: time %s: analysis took %s secs\n", + g_fprintf(stderr, _("%s: time %s: analysis took %s secs\n"), get_pname(), walltime_str(curclock()), walltime_str(timessub(curclock(), section_start))); @@ -542,26 +597,21 @@ char **argv; * on stderr for the debug file. */ - fprintf(stderr,"\nGENERATING SCHEDULE:\n--------\n"); + g_fprintf(stderr,_("\nGENERATING SCHEDULE:\n--------\n")); while(!empty(schedq)) output_scheduleline(dequeue_disk(&schedq)); - fprintf(stderr, "--------\n"); + g_fprintf(stderr, _("--------\n")); close_infofile(); - log_add(L_FINISH, "date %s time %s", datestamp, walltime_str(curclock())); + log_add(L_FINISH, _("date %s time %s"), planner_timestamp, walltime_str(curclock())); - amfree(datestamp); - amfree(config_dir); - amfree(config_name); + clear_tapelist(); + amfree(planner_timestamp); amfree(our_feature_string); am_release_feature_set(our_features); our_features = NULL; - malloc_size_2 = malloc_inuse(&malloc_hist_2); - - if(malloc_size_1 != malloc_size_2) { - malloc_list(fileno(stderr), malloc_hist_1, malloc_hist_2); - } + dbclose(); return 0; } @@ -574,74 +624,79 @@ char **argv; * */ -static void askfor P((est_t *, int, int, info_t *)); -static int last_level P((info_t *info)); /* subroutines */ -static long est_size P((disk_t *dp, int level)); -static long est_tape_size P((disk_t *dp, int level)); -static int next_level0 P((disk_t *dp, info_t *info)); -static int runs_at P((info_t *info, int lev)); -static long bump_thresh P((int level, long size_level_0, int bumppercent, int bumpsize, double bumpmult)); -static int when_overwrite P((char *label)); - -static void askfor(ep, seq, lev, info) -est_t *ep; /* esimate data block */ -int seq; /* sequence number of request */ -int lev; /* dump level being requested */ -info_t *info; /* info block for disk */ +static void askfor(est_t *, int, int, info_t *); +static int last_level(info_t *info); /* subroutines */ +static off_t est_size(disk_t *dp, int level); +static off_t est_tape_size(disk_t *dp, int level); +static int next_level0(disk_t *dp, info_t *info); +static int runs_at(info_t *info, int lev); +static off_t bump_thresh(int level, off_t size_level_0, int bumppercent, off_t bumpsize, double bumpmult); +static int when_overwrite(char *label); + +static void askfor( + est_t *ep, /* esimate data block */ + int seq, /* sequence number of request */ + int lev, /* dump level being requested */ + info_t *info) /* info block for disk */ { if(seq < 0 || seq >= MAX_LEVELS) { - error("error [planner askfor: seq out of range 0..%d: %d]", + error(_("error [planner askfor: seq out of range 0..%d: %d]"), MAX_LEVELS, seq); + /*NOTREACHED*/ } if(lev < -1 || lev >= DUMP_LEVELS) { - error("error [planner askfor: lev out of range -1..%d: %d]", + error(_("error [planner askfor: lev out of range -1..%d: %d]"), DUMP_LEVELS, lev); + /*NOTREACHED*/ } if (lev == -1) { ep->level[seq] = -1; ep->dumpdate[seq] = (char *)0; - ep->est_size[seq] = -2; + ep->est_size[seq] = (off_t)-2; return; } ep->level[seq] = lev; ep->dumpdate[seq] = stralloc(get_dumpdate(info,lev)); - malloc_mark(ep->dumpdate[seq]); - ep->est_size[seq] = -2; + ep->est_size[seq] = (off_t)-2; return; } static void -setup_estimate(dp) - disk_t *dp; +setup_estimate( + disk_t *dp) { est_t *ep; info_t info; int i; + char *qname; + int overwrite_runs; assert(dp && dp->host); - fprintf(stderr, "%s: time %s: setting up estimates for %s:%s\n", + + qname = quote_string(dp->name); + g_fprintf(stderr, _("%s: time %s: setting up estimates for %s:%s\n"), get_pname(), walltime_str(curclock()), - dp->host->hostname, dp->name); + dp->host->hostname, qname); /* get current information about disk */ if(get_info(dp->host->hostname, dp->name, &info)) { /* no record for this disk, make a note of it */ - log_add(L_INFO, "Adding new disk %s:%s.", dp->host->hostname, dp->name); + log_add(L_INFO, _("Adding new disk %s:%s."), dp->host->hostname, dp->name); } /* setup working data struct for disk */ - ep = alloc(sizeof(est_t)); - malloc_mark(ep); + ep = alloc(SIZEOF(est_t)); dp->up = (void *) ep; ep->state = DISK_READY; - ep->dump_size = -1; + ep->dump_nsize = (off_t)-1; + ep->dump_csize = (off_t)-1; ep->dump_priority = dp->priority; ep->errstr = 0; ep->promote = 0; @@ -663,22 +718,24 @@ setup_estimate(dp) * now. */ log_add(L_ERROR, - "Cannot force full dump of %s:%s with no-full option.", - dp->host->hostname, dp->name); + _("Cannot force full dump of %s:%s with no-full option."), + dp->host->hostname, qname); /* clear force command */ CLR(info.command, FORCE_FULL); - if(put_info(dp->host->hostname, dp->name, &info)) - error("could not put info record for %s:%s: %s", - dp->host->hostname, dp->name, strerror(errno)); + if(put_info(dp->host->hostname, dp->name, &info)) { + error(_("could not put info record for %s:%s: %s"), + dp->host->hostname, qname, strerror(errno)); + /*NOTREACHED*/ + } ep->last_level = last_level(&info); ep->next_level0 = next_level0(dp, &info); } else { ep->last_level = -1; ep->next_level0 = -conf_dumpcycle; - log_add(L_INFO, "Forcing full dump of %s:%s as directed.", - dp->host->hostname, dp->name); + log_add(L_INFO, _("Forcing full dump of %s:%s as directed."), + dp->host->hostname, qname); } } else if(dp->strategy == DS_NOFULL) { @@ -693,26 +750,28 @@ setup_estimate(dp) /* adjust priority levels */ + /* warn if dump will be overwritten */ + if (ep->last_level > -1 && strlen(info.inf[0].label) > 0) { + overwrite_runs = when_overwrite(info.inf[0].label); + if(overwrite_runs == 0) { + log_add(L_WARNING, _("Last full dump of %s:%s " + "on tape %s overwritten on this run."), + dp->host->hostname, qname, info.inf[0].label); + } else if(overwrite_runs <= RUNS_REDZONE) { + log_add(L_WARNING, + plural(_("Last full dump of %s:%s on tape %s overwritten in %d run."), + _("Last full dump of %s:%s on tape %s overwritten in %d runs."), overwrite_runs), + dp->host->hostname, qname, info.inf[0].label, + overwrite_runs); + } + } + if(ep->next_level0 < 0) { - fprintf(stderr,"%s:%s overdue %d day%s for level 0\n", - dp->host->hostname, dp->name, - - ep->next_level0, ((- ep->next_level0) == 1) ? "" : "s"); + g_fprintf(stderr,plural(_("%s:%s overdue %d day for level 0\n"), + _("%s:%s overdue %d days for level 0\n"), + (-ep->next_level0)), + dp->host->hostname, qname, (-ep->next_level0)); ep->dump_priority -= ep->next_level0; - /* warn if dump will be overwritten */ - if(ep->last_level > -1) { - int overwrite_runs = when_overwrite(info.inf[0].label); - if(overwrite_runs == 0) { - log_add(L_WARNING, - "Last full dump of %s:%s on tape %s overwritten on this run.", - dp->host->hostname, dp->name, info.inf[0].label); - } - else if(overwrite_runs < RUNS_REDZONE) { - log_add(L_WARNING, - "Last full dump of %s:%s on tape %s overwritten in %d run%s.", - dp->host->hostname, dp->name, info.inf[0].label, - overwrite_runs, overwrite_runs == 1? "" : "s"); - } - } } else if (ISSET(info.command, FORCE_FULL)) ep->dump_priority += 1; @@ -727,21 +786,24 @@ setup_estimate(dp) CLR(info.command, FORCE_FULL); ep->next_level0 += conf_dumpcycle; ep->last_level = 0; - if(put_info(dp->host->hostname, dp->name, &info)) - error("could not put info record for %s:%s: %s", - dp->host->hostname, dp->name, strerror(errno)); - log_add(L_INFO, "Skipping full dump of %s:%s today.", - dp->host->hostname, dp->name); - fprintf(stderr,"%s:%s lev 0 skipped due to skip-full flag\n", - dp->host->hostname, dp->name); + if(put_info(dp->host->hostname, dp->name, &info)) { + error(_("could not put info record for %s:%s: %s"), + dp->host->hostname, qname, strerror(errno)); + /*NOTREACHED*/ + } + log_add(L_INFO, _("Skipping full dump of %s:%s today."), + dp->host->hostname, qname); + g_fprintf(stderr,_("%s:%s lev 0 skipped due to skip-full flag\n"), + dp->host->hostname, qname); /* don't enqueue the disk */ askfor(ep, 0, -1, &info); askfor(ep, 1, -1, &info); askfor(ep, 2, -1, &info); - fprintf(stderr, "%s: SKIPPED %s %s 0 [skip-full]\n", - get_pname(), dp->host->hostname, dp->name); - log_add(L_SUCCESS, "%s %s %s 0 [skipped: skip-full]", - dp->host->hostname, dp->name, datestamp); + g_fprintf(stderr, _("%s: SKIPPED %s %s 0 [skip-full]\n"), + get_pname(), dp->host->hostname, qname); + log_add(L_SUCCESS, _("%s %s %s 0 [skipped: skip-full]"), + dp->host->hostname, qname, planner_timestamp); + amfree(qname); return; } @@ -751,8 +813,8 @@ setup_estimate(dp) } if(ep->next_level0 == 1) { - log_add(L_WARNING, "Skipping full dump of %s:%s tomorrow.", - dp->host->hostname, dp->name); + log_add(L_WARNING, _("Skipping full dump of %s:%s tomorrow."), + dp->host->hostname, qname); } } @@ -761,37 +823,39 @@ setup_estimate(dp) askfor(ep, 0, -1, &info); askfor(ep, 1, -1, &info); askfor(ep, 2, -1, &info); - log_add(L_FAIL, "%s %s 19000101 1 [Skipping incronly because no full dump were done]", - dp->host->hostname, dp->name); - fprintf(stderr,"%s:%s lev 1 skipped due to strategy incronly and no full dump were done\n", - dp->host->hostname, dp->name); + log_add(L_FAIL, _("%s %s 19000101 1 [Skipping incronly because no full dump were done]"), + dp->host->hostname, qname); + g_fprintf(stderr,_("%s:%s lev 1 skipped due to strategy incronly and no full dump were done\n"), + dp->host->hostname, qname); + amfree(qname); return; } /* handle "skip-incr" type archives */ if(dp->skip_incr && ep->next_level0 > 0) { - fprintf(stderr,"%s:%s lev 1 skipped due to skip-incr flag\n", - dp->host->hostname, dp->name); + g_fprintf(stderr,_("%s:%s lev 1 skipped due to skip-incr flag\n"), + dp->host->hostname, qname); /* don't enqueue the disk */ askfor(ep, 0, -1, &info); askfor(ep, 1, -1, &info); askfor(ep, 2, -1, &info); - fprintf(stderr, "%s: SKIPPED %s %s 1 [skip-incr]\n", - get_pname(), dp->host->hostname, dp->name); + g_fprintf(stderr, _("%s: SKIPPED %s %s 1 [skip-incr]\n"), + get_pname(), dp->host->hostname, qname); - log_add(L_SUCCESS, "%s %s %s 1 [skipped: skip-incr]", - dp->host->hostname, dp->name, datestamp); + log_add(L_SUCCESS, _("%s %s %s 1 [skipped: skip-incr]"), + dp->host->hostname, qname, planner_timestamp); + amfree(qname); return; } if( ep->last_level == -1 && ep->next_level0 > 0 && dp->strategy != DS_NOFULL && dp->strategy != DS_INCRONLY && conf_reserve == 100) { - log_add(L_WARNING, - "%s:%s mismatch: no tapelist record, but curinfo next_level0: %d.", - dp->host->hostname, dp->name, ep->next_level0); + log_add(L_WARNING, _("%s:%s mismatch: no tapelist record, " + "but curinfo next_level0: %d."), + dp->host->hostname, qname, ep->next_level0); ep->next_level0 = 0; } @@ -816,22 +880,22 @@ setup_estimate(dp) ep->last_level == -1))) { if(info.command & FORCE_BUMP && ep->last_level == -1) { log_add(L_INFO, - "Remove force-bump command of %s:%s because it's a new disk.", - dp->host->hostname, dp->name); + _("Remove force-bump command of %s:%s because it's a new disk."), + dp->host->hostname, qname); } switch (dp->strategy) { case DS_STANDARD: case DS_NOINC: askfor(ep, i++, 0, &info); if(dp->skip_full) { - log_add(L_INFO, - "Ignoring skip_full for %s:%s because the strategy is NOINC.", - dp->host->hostname, dp->name); + log_add(L_INFO, _("Ignoring skip_full for %s:%s " + "because the strategy is NOINC."), + dp->host->hostname, qname); } if(info.command & FORCE_BUMP) { log_add(L_INFO, - "Ignoring FORCE_BUMP for %s:%s because the strategy is NOINC.", - dp->host->hostname, dp->name); + _("Ignoring FORCE_BUMP for %s:%s because the strategy is NOINC."), + dp->host->hostname, qname); } break; @@ -862,13 +926,13 @@ setup_estimate(dp) if(curr_level > 0) { /* level 0 already asked for */ askfor(ep, i++, curr_level, &info); } - log_add(L_INFO,"Preventing bump of %s:%s as directed.", - dp->host->hostname, dp->name); + log_add(L_INFO,_("Preventing bump of %s:%s as directed."), + dp->host->hostname, qname); } else if (ISSET(info.command, FORCE_BUMP) && curr_level + 1 < DUMP_LEVELS) { askfor(ep, i++, curr_level+1, &info); - log_add(L_INFO,"Bumping of %s:%s at level %d as directed.", - dp->host->hostname, dp->name, curr_level+1); + log_add(L_INFO,_("Bumping of %s:%s at level %d as directed."), + dp->host->hostname, qname, curr_level+1); } else if (curr_level == 0) { askfor(ep, i++, 1, &info); } else { @@ -880,7 +944,7 @@ setup_estimate(dp) * if we haven't been at this level 2 days, or the dump failed * last night, we can't bump. */ - if((info.inf[curr_level].size == 0 || /* no data, try it anyway */ + if((info.inf[curr_level].size == (off_t)0 || /* no data, try it anyway */ (((info.inf[curr_level].size > bump_thresh(curr_level, info.inf[0].size,dp->bumppercent, dp->bumpsize, dp->bumpmult))) && ep->level_days >= dp->bumpdays)) && curr_level + 1 < DUMP_LEVELS) { @@ -895,23 +959,26 @@ setup_estimate(dp) /* debug output */ - fprintf(stderr, "setup_estimate: %s:%s: command %d, options: %s last_level %d next_level0 %d level_days %d getting estimates %d (%ld) %d (%ld) %d (%ld)\n", - dp->host->hostname, dp->name, info.command, + g_fprintf(stderr, _("setup_estimate: %s:%s: command %u, options: %s " + "last_level %d next_level0 %d level_days %d getting estimates " + "%d (%lld) %d (%lld) %d (%lld)\n"), + dp->host->hostname, qname, info.command, dp->strategy == DS_NOFULL ? "no-full" : dp->strategy == DS_INCRONLY ? "incr-only" : dp->skip_full ? "skip-full" : dp->skip_incr ? "skip-incr" : "none", ep->last_level, ep->next_level0, ep->level_days, - ep->level[0], ep->est_size[0], - ep->level[1], ep->est_size[1], - ep->level[2], ep->est_size[2]); + ep->level[0], (long long)ep->est_size[0], + ep->level[1], (long long)ep->est_size[1], + ep->level[2], (long long)ep->est_size[2]); assert(ep->level[0] != -1); enqueue_disk(&startq, dp); + amfree(qname); } -static int when_overwrite(label) -char *label; +static int when_overwrite( + char *label) { tape_t *tp; int runtapes; @@ -921,7 +988,7 @@ char *label; if((tp = lookup_tapelabel(label)) == NULL) return 1; /* "shouldn't happen", but trigger warning message */ - else if(!reusable_tape(tp)) + else if(tp->reuse == 0) return 1024; else if(lookup_nb_tape() > conf_tapecycle) return (lookup_nb_tape() - tp->position) / runtapes; @@ -930,9 +997,9 @@ char *label; } /* Return the estimated size for a particular dump */ -static long est_size(dp, level) -disk_t *dp; -int level; +static off_t est_size( + disk_t *dp, + int level) { int i; @@ -940,20 +1007,20 @@ int level; if(level == est(dp)->level[i]) return est(dp)->est_size[i]; } - return -1; + return (off_t)-1; } /* Return the estimated on-tape size of a particular dump */ -static long est_tape_size(dp, level) -disk_t *dp; -int level; +static off_t est_tape_size( + disk_t *dp, + int level) { - long size; + off_t size; double ratio; size = est_size(dp, level); - if(size == -1) return size; + if(size == (off_t)-1) return size; if(dp->compress == COMP_NONE) return size; @@ -972,15 +1039,15 @@ int level; if(ratio > 1.1) ratio = 1.1; - size *= ratio; + size = (off_t)((double)size * ratio); /* * Ratio can be very small in some error situations, so make sure * size goes back greater than zero. It may not be right, but * indicates we did get an estimate. */ - if(size <= 0) { - size = 1; + if(size <= (off_t)0) { + size = (off_t)1; } return size; @@ -988,8 +1055,8 @@ int level; /* what was the level of the last successful dump to tape? */ -static int last_level(info) -info_t *info; +static int last_level( + info_t *info) { int min_pos, min_level, i; time_t lev0_date, last_date; @@ -1030,9 +1097,9 @@ info_t *info; /* when is next level 0 due? 0 = today, 1 = tomorrow, etc*/ static int -next_level0(dp, info) - disk_t *dp; - info_t *info; +next_level0( + disk_t *dp, + info_t *info) { if(dp->strategy == DS_NOFULL || dp->strategy == DS_INCRONLY) return 1; /* fake it */ @@ -1045,9 +1112,9 @@ next_level0(dp, info) } /* how many runs at current level? */ -static int runs_at(info, lev) -info_t *info; -int lev; +static int runs_at( + info_t *info, + int lev) { tape_t *cur_tape, *old_tape; int last, nb_runs; @@ -1074,24 +1141,24 @@ int lev; } -static long bump_thresh(level, size_level_0, bumppercent, bumpsize, bumpmult) -int level; -long size_level_0; -int bumppercent; -int bumpsize; -double bumpmult; +static off_t bump_thresh( + int level, + off_t size_level_0, + int bumppercent, + off_t bumpsize, + double bumpmult) { double bump; - if(bumppercent != 0 && size_level_0 > 1024) { - bump = (size_level_0 * bumppercent)/100.0; + if ((bumppercent != 0) && (size_level_0 > (off_t)1024)) { + bump = ((double)size_level_0 * (double)bumppercent) / 100.0; } else { - bump = bumpsize; + bump = (double)bumpsize; } while(--level) bump = bump * bumpmult; - return (long)bump; + return (off_t)bump; } @@ -1102,12 +1169,12 @@ double bumpmult; * */ -static void getsize P((am_host_t *hostp)); -static disk_t *lookup_hostdisk P((am_host_t *hp, char *str)); -static void handle_result P((void *datap, pkt_t *pkt, security_handle_t *sech)); +static void getsize(am_host_t *hostp); +static disk_t *lookup_hostdisk(am_host_t *hp, char *str); +static void handle_result(void *datap, pkt_t *pkt, security_handle_t *sech); -static void get_estimates P((void)) +static void get_estimates(void) { am_host_t *hostp; disk_t *dp; @@ -1134,83 +1201,82 @@ static void get_estimates P((void)) while(!empty(waitq)) { disk_t *dp = dequeue_disk(&waitq); - est(dp)->errstr = "hmm, disk was stranded on waitq"; + est(dp)->errstr = _("hmm, disk was stranded on waitq"); enqueue_disk(&failq, dp); } while(!empty(pestq)) { disk_t *dp = dequeue_disk(&pestq); - - if(est(dp)->level[0] != -1 && est(dp)->est_size[0] < 0) { - if(est(dp)->est_size[0] == -1) { - log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, - est(dp)->level[0]); + char * qname = quote_string(dp->name); + + if(est(dp)->level[0] != -1 && est(dp)->est_size[0] < (off_t)0) { + if(est(dp)->est_size[0] == (off_t)-1) { + log_add(L_WARNING, _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[0]); } else { log_add(L_WARNING, - "disk %s:%s, estimate of level %d timed out.", - dp->host->hostname, dp->name, - est(dp)->level[0]); + _("disk %s:%s, estimate of level %d timed out."), + dp->host->hostname, qname, est(dp)->level[0]); } est(dp)->level[0] = -1; } - if(est(dp)->level[1] != -1 && est(dp)->est_size[1] < 0) { - if(est(dp)->est_size[1] == -1) { + if(est(dp)->level[1] != -1 && est(dp)->est_size[1] < (off_t)0) { + if(est(dp)->est_size[1] == (off_t)-1) { log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, - est(dp)->level[1]); + _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[1]); } else { log_add(L_WARNING, - "disk %s:%s, estimate of level %d timed out.", - dp->host->hostname, dp->name, - est(dp)->level[1]); + _("disk %s:%s, estimate of level %d timed out."), + dp->host->hostname, qname, est(dp)->level[1]); } est(dp)->level[1] = -1; } - if(est(dp)->level[2] != -1 && est(dp)->est_size[2] < 0) { - if(est(dp)->est_size[2] == -1) { + if(est(dp)->level[2] != -1 && est(dp)->est_size[2] < (off_t)0) { + if(est(dp)->est_size[2] == (off_t)-1) { log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, - est(dp)->level[2]); + _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[2]); } else { log_add(L_WARNING, - "disk %s:%s, estimate of level %d timed out.", - dp->host->hostname, dp->name, - est(dp)->level[2]); + _("disk %s:%s, estimate of level %d timed out."), + dp->host->hostname, qname, est(dp)->level[2]); } est(dp)->level[2] = -1; } - if((est(dp)->level[0] != -1 && est(dp)->est_size[0] > 0) || - (est(dp)->level[1] != -1 && est(dp)->est_size[1] > 0) || - (est(dp)->level[2] != -1 && est(dp)->est_size[2] > 0)) { + if((est(dp)->level[0] != -1 && est(dp)->est_size[0] > (off_t)0) || + (est(dp)->level[1] != -1 && est(dp)->est_size[1] > (off_t)0) || + (est(dp)->level[2] != -1 && est(dp)->est_size[2] > (off_t)0)) { enqueue_disk(&estq, dp); } else { - est(dp)->errstr = vstralloc("disk ", dp->name, - ", all estimate timed out", NULL); + est(dp)->errstr = vstralloc("disk ", qname, + _(", all estimate timed out"), NULL); enqueue_disk(&failq, dp); } + amfree(qname); } } -static void getsize(hostp) -am_host_t *hostp; +static void getsize( + am_host_t *hostp) { - char number[NUM_STR_SIZE], *req; - disk_t *dp; - int i, estimates, timeout, req_len; - const security_driver_t *secdrv; - char *dumper; - char *calcsize; + char number[NUM_STR_SIZE], *req; + disk_t * dp; + int i; + time_t estimates, timeout; + size_t req_len; + const security_driver_t *secdrv; + char * backup_api; + char * calcsize; + char * qname; + char * qdevice; assert(hostp->disks != NULL); @@ -1235,8 +1301,10 @@ am_host_t *hostp; fe_req_options_hostname); int has_maxdumps = am_has_feature(hostp->features, fe_req_options_maxdumps); + int has_config = am_has_feature(hostp->features, + fe_req_options_config); - snprintf(number, sizeof(number), "%d", hostp->maxdumps); + g_snprintf(number, SIZEOF(number), "%d", hostp->maxdumps); req = vstralloc("SERVICE ", "sendsize", "\n", "OPTIONS ", has_features ? "features=" : "", @@ -1248,14 +1316,17 @@ am_host_t *hostp; has_hostname ? "hostname=" : "", has_hostname ? hostp->hostname : "", has_hostname ? ";" : "", + has_config ? "config=" : "", + has_config ? config_name : "", + has_config ? ";" : "", "\n", NULL); req_len = strlen(req); - req_len += 128; /* room for SECURITY ... */ + req_len += 128; /* room for SECURITY ... */ estimates = 0; for(dp = hostp->disks; dp != NULL; dp = dp->hostnext) { char *s = NULL; - int s_len = 0; + size_t s_len = 0; if(dp->todo == 0) continue; @@ -1267,6 +1338,8 @@ am_host_t *hostp; continue; } + qname = quote_string(dp->name); + qdevice = quote_string(dp->device); if(dp->estimate == ES_CLIENT || dp->estimate == ES_CALCSIZE) { nb_client++; @@ -1276,36 +1349,61 @@ am_host_t *hostp; char *exclude1 = ""; char *exclude2 = ""; char *excludefree = NULL; + char *include1 = ""; + char *include2 = ""; + char *includefree = NULL; char spindle[NUM_STR_SIZE]; char level[NUM_STR_SIZE]; int lev = est(dp)->level[i]; if(lev == -1) break; - snprintf(level, sizeof(level), "%d", lev); - snprintf(spindle, sizeof(spindle), "%d", dp->spindle); + g_snprintf(level, SIZEOF(level), "%d", lev); + g_snprintf(spindle, SIZEOF(spindle), "%d", dp->spindle); if(am_has_feature(hostp->features,fe_sendsize_req_options)){ exclude1 = " OPTIONS |"; exclude2 = optionstr(dp, hostp->features, NULL); + if ( exclude2 == NULL ) { + error(_("problem with option string, check the dumptype definition.\n")); + } excludefree = exclude2; + includefree = NULL; } else { if(dp->exclude_file && dp->exclude_file->nb_element == 1) { exclude1 = " exclude-file="; - exclude2 = dp->exclude_file->first->name; + exclude2 = + quote_string(dp->exclude_file->first->name); + excludefree = exclude2; } else if(dp->exclude_list && dp->exclude_list->nb_element == 1) { exclude1 = " exclude-list="; - exclude2 = dp->exclude_list->first->name; + exclude2 = + quote_string(dp->exclude_list->first->name); + excludefree = exclude2; + } + if(dp->include_file && + dp->include_file->nb_element == 1) { + include1 = " include-file="; + include2 = + quote_string(dp->include_file->first->name); + includefree = include2; + } + else if(dp->include_list && + dp->include_list->nb_element == 1) { + include1 = " include-list="; + include2 = + quote_string(dp->include_list->first->name); + includefree = include2; } } if(dp->estimate == ES_CALCSIZE && !am_has_feature(hostp->features, fe_calcsize_estimate)) { - log_add(L_WARNING,"%s:%s does not support CALCSIZE for estimate, using CLIENT.\n", - hostp->hostname, dp->name); + log_add(L_WARNING,_("%s:%s does not support CALCSIZE for estimate, using CLIENT.\n"), + hostp->hostname, qname); dp->estimate = ES_CLIENT; } if(dp->estimate == ES_CLIENT) @@ -1313,35 +1411,31 @@ am_host_t *hostp; else calcsize = "CALCSIZE "; - if(strncmp(dp->program,"DUMP",4) == 0 || - strncmp(dp->program,"GNUTAR",6) == 0) { - dumper = ""; + if(strcmp(dp->program,"DUMP") == 0 || + strcmp(dp->program,"GNUTAR") == 0) { + backup_api = ""; } else { - dumper = "DUMPER "; + backup_api = "BACKUP "; } l = vstralloc(calcsize, - dumper, + backup_api, dp->program, - " ", dp->name, - " ", dp->device ? dp->device : "", + " ", qname, + " ", dp->device ? qdevice : "", " ", level, " ", est(dp)->dumpdate[i], " ", spindle, " ", exclude1, exclude2, + ((includefree != NULL) ? " " : ""), + include1, include2, "\n", NULL); strappend(s, l); s_len += strlen(l); amfree(l); + amfree(includefree); amfree(excludefree); } - /* - * Allow 2X for err response. - */ - if(req_len + s_len > MAX_PACKET / 2) { - amfree(s); - break; - } if (s != NULL) { estimates += i; strappend(req, s); @@ -1361,12 +1455,12 @@ am_host_t *hostp; if(lev == -1) break; if(lev == 0) { /* use latest level 0, should do extrapolation */ - long est_size = 0; + off_t est_size = (off_t)0; int nb_est = 0; for(j=NB_HISTORY-2;j>=0;j--) { if(info.history[j].level == 0) { - if(info.history[j].size < 0) continue; + if(info.history[j].size < (off_t)0) continue; est_size = info.history[j].size; nb_est++; } @@ -1374,27 +1468,27 @@ am_host_t *hostp; if(nb_est > 0) { est(dp)->est_size[i] = est_size; } - else if(info.inf[lev].size > 1000) { /* stats */ + else if(info.inf[lev].size > (off_t)1000) { /* stats */ est(dp)->est_size[i] = info.inf[lev].size; } else { - est(dp)->est_size[i] = 1000000; + est(dp)->est_size[i] = (off_t)1000000; } } else if(lev == est(dp)->last_level) { /* means of all X day at the same level */ #define NB_DAY 30 int nb_day = 0; - long est_size_day[NB_DAY]; + off_t est_size_day[NB_DAY]; int nb_est_day[NB_DAY]; for(j=0;j=0;j--) { if(info.history[j].level <= 0) continue; - if(info.history[j].size < 0) continue; + if(info.history[j].size < (off_t)0) continue; if(info.history[j].level==info.history[j+1].level) { if(nb_day 0 && nb_est_day[nb_day] == 0) nb_day--; if(nb_est_day[nb_day] > 0) { - est(dp)->est_size[i] = - est_size_day[nb_day] / nb_est_day[nb_day]; + est(dp)->est_size[i] = est_size_day[nb_day] / + (off_t)nb_est_day[nb_day]; } - else if(info.inf[lev].size > 1000) { /* stats */ + else if(info.inf[lev].size > (off_t)1000) { /* stats */ est(dp)->est_size[i] = info.inf[lev].size; } else { - est(dp)->est_size[i] = 10000; + est(dp)->est_size[i] = (off_t)10000; } } else if(lev == est(dp)->last_level + 1) { /* means of all first day at a new level */ - long est_size = 0; + off_t est_size = (off_t)0; int nb_est = 0; for(j=NB_HISTORY-2;j>=0;j--) { if(info.history[j].level <= 0) continue; - if(info.history[j].size < 0) continue; + if(info.history[j].size < (off_t)0) continue; if(info.history[j].level == info.history[j+1].level + 1 ) { est_size += info.history[j].size; nb_est++; } } if(nb_est > 0) { - est(dp)->est_size[i] = est_size / nb_est; + est(dp)->est_size[i] = est_size / (off_t)nb_est; } - else if(info.inf[lev].size > 1000) { /* stats */ + else if(info.inf[lev].size > (off_t)1000) { /* stats */ est(dp)->est_size[i] = info.inf[lev].size; } else { - est(dp)->est_size[i] = 100000; + est(dp)->est_size[i] = (off_t)100000; } } - } - fprintf(stderr,"%s time %s: got result for host %s disk %s:", + } + g_fprintf(stderr,_("%s time %s: got result for host %s disk %s:"), get_pname(), walltime_str(curclock()), - dp->host->hostname, dp->name); - fprintf(stderr," %d -> %ldK, %d -> %ldK, %d -> %ldK\n", - est(dp)->level[0], est(dp)->est_size[0], - est(dp)->level[1], est(dp)->est_size[1], - est(dp)->level[2], est(dp)->est_size[2]); + dp->host->hostname, qname); + g_fprintf(stderr,_(" %d -> %lldK, %d -> %lldK, %d -> %lldK\n"), + est(dp)->level[0], (long long)est(dp)->est_size[0], + est(dp)->level[1], (long long)est(dp)->est_size[1], + est(dp)->level[2], (long long)est(dp)->est_size[2]); est(dp)->state = DISK_DONE; remove_disk(&startq, dp); enqueue_disk(&estq, dp); } + amfree(qname); + amfree(qdevice); } if(estimates == 0) { @@ -1478,13 +1574,17 @@ am_host_t *hostp; * We use ctimeout for the "noop" request because it should be * very fast and etimeout has other side effects. */ - timeout = getconf_int(CNF_CTIMEOUT); + timeout = (time_t)getconf_int(CNF_CTIMEOUT); } secdrv = security_getdriver(hostp->disks->security_driver); if (secdrv == NULL) { - error("could not find security driver '%s' for host '%s'", - hostp->disks->security_driver, hostp->hostname); + hostp->up = HOST_DONE; + log_add(L_ERROR, + _("Could not find security driver '%s' for host '%s'"), + hostp->disks->security_driver, hostp->hostname); + amfree(req); + return; } hostp->up = HOST_ACTIVE; @@ -1498,14 +1598,15 @@ am_host_t *hostp; } } - protocol_sendreq(hostp->hostname, secdrv, generic_get_security_conf, + protocol_sendreq(hostp->hostname, secdrv, amhost_get_security_conf, req, timeout, handle_result, hostp); + amfree(req); } -static disk_t *lookup_hostdisk(hp, str) -am_host_t *hp; -char *str; +static disk_t *lookup_hostdisk( + /*@keep@*/ am_host_t *hp, + char *str) { disk_t *dp; @@ -1516,16 +1617,16 @@ char *str; } -static void handle_result(datap, pkt, sech) -void *datap; -pkt_t *pkt; -security_handle_t *sech; +static void handle_result( + void *datap, + pkt_t *pkt, + security_handle_t *sech) { int level, i; - long size; + off_t size; disk_t *dp; am_host_t *hostp; - char *msgdisk=NULL, *msgdisk_undo=NULL, msgdisk_undo_ch = '\0'; + char *msg, msg_undo; char *remoterr, *errbuf = NULL; char *s; char *t; @@ -1533,21 +1634,22 @@ security_handle_t *sech; char *line; int ch; int tch; + char *qname; + char *disk; + long long size_; hostp = (am_host_t *)datap; hostp->up = HOST_READY; if (pkt == NULL) { - errbuf = vstralloc("Request to ", hostp->hostname, " failed: ", - security_geterror(sech), NULL); + errbuf = vstrallocf(_("Request to %s failed: %s"), + hostp->hostname, security_geterror(sech)); goto error_return; } if (pkt->type == P_NAK) { -#define sc "ERROR " - if(strncmp(pkt->body, sc, sizeof(sc)-1) == 0) { - s = pkt->body + sizeof(sc)-1; + s = pkt->body; + if(strncmp_const_skip(s, "ERROR ", s, ch) == 0) { ch = *s++; -#undef sc } else { goto NAK_parse_failed; } @@ -1559,57 +1661,41 @@ security_handle_t *sech; *s = '\0'; } if (strcmp(remoterr, "unknown service: noop") != 0 - && strcmp(remoterr, "noop: invalid service") != 0) { + && strcmp(remoterr, "noop: invalid service") != 0) { errbuf = vstralloc(hostp->hostname, " NAK: ", remoterr, NULL); if(s) *s = '\n'; goto error_return; } } - msgdisk_undo = NULL; s = pkt->body; ch = *s++; while(ch) { line = s - 1; - skip_line(s, ch); - if (s[-2] == '\n') { - s[-2] = '\0'; - } - -#define sc "OPTIONS " - if(strncmp(line, sc, sizeof(sc)-1) == 0) { -#undef sc -#define sc "features=" - t = strstr(line, sc); + if(strncmp_const(line, "OPTIONS ") == 0) { + t = strstr(line, "features="); if(t != NULL && (isspace((int)t[-1]) || t[-1] == ';')) { - t += sizeof(sc)-1; -#undef sc + t += SIZEOF("features=")-1; am_release_feature_set(hostp->features); if((hostp->features = am_string_to_feature(t)) == NULL) { - errbuf = vstralloc(hostp->hostname, - ": bad features value: ", - line, - "\n", - NULL); + errbuf = vstrallocf(hostp->hostname, + _(": bad features value: %s\n"), line); goto error_return; } } - + skip_quoted_line(s, ch); continue; } -#define sc "ERROR " - if(strncmp(line, sc, sizeof(sc)-1) == 0) { - t = line + sizeof(sc)-1; - tch = t[-1]; -#undef sc - + t = line; + if(strncmp_const_skip(t, "ERROR ", t, tch) == 0) { fp = t - 1; skip_whitespace(t, tch); if (tch == '\n') { t[-1] = '\0'; } + /* * If the "error" is that the "noop" service is unknown, it * just means the client is "old" (does not support the servie). @@ -1618,39 +1704,65 @@ security_handle_t *sech; if(hostp->features == NULL && pkt->type == P_NAK && (strcmp(t - 1, "unknown service: noop") == 0 - || strcmp(t - 1, "noop: invalid service") == 0)) { + || strcmp(t - 1, "noop: invalid service") == 0)) { + skip_quoted_line(s, ch); continue; - } else { - errbuf = vstralloc(hostp->hostname, - (pkt->type == P_NAK) ? "NAK " : "", - ": ", - fp, - NULL); - goto error_return; } + errbuf = vstralloc(hostp->hostname, + (pkt->type == P_NAK) ? "NAK " : "", + ": ", + fp, + NULL); + goto error_return; } - msgdisk = t = line; - tch = *t++; - skip_non_whitespace(t, tch); - msgdisk_undo = t - 1; - msgdisk_undo_ch = *msgdisk_undo; - *msgdisk_undo = '\0'; + msg = t = line; + tch = *(t++); + skip_quoted_string(t, tch); + t[-1] = '\0'; + disk = unquote_string(msg); skip_whitespace(t, tch); - if (sscanf(t - 1, "%d SIZE %ld", &level, &size) != 2) { + + if (sscanf(t - 1, "%d", &level) != 1) { goto bad_msg; } - dp = lookup_hostdisk(hostp, msgdisk); - - *msgdisk_undo = msgdisk_undo_ch; /* for error message */ - msgdisk_undo = NULL; + skip_integer(t, tch); + skip_whitespace(t, tch); + dp = lookup_hostdisk(hostp, disk); + dp = lookup_hostdisk(hostp, disk); if(dp == NULL) { - log_add(L_ERROR, "%s: invalid reply from sendsize: `%s'\n", + log_add(L_ERROR, _("%s: invalid reply from sendsize: `%s'\n"), hostp->hostname, line); + goto bad_msg; + } + + size = (off_t)-1; + if (strncmp_const(t-1,"SIZE ") == 0) { + if (sscanf(t - 1, "SIZE %lld", &size_) != 1) { + goto bad_msg; + } + size = (off_t)size_; + } else if (strncmp_const(t-1,"ERROR ") == 0) { + skip_non_whitespace(t, tch); + skip_whitespace(t, tch); + msg = t-1; + skip_quoted_string(t,tch); + msg_undo = t[-1]; + t[-1] = '\0'; + if (pkt->type == P_REP) { + est(dp)->errstr = unquote_string(msg); + } + t[-1] = msg_undo; } else { + goto bad_msg; + } + + amfree(disk); + + if (size > (off_t)-1) { for(i = 0; i < MAX_LEVELS; i++) { if(est(dp)->level[i] == level) { est(dp)->est_size[i] = size; @@ -1662,6 +1774,9 @@ security_handle_t *sech; } est(dp)->got_estimate++; } + s = t; + ch = tch; + skip_quoted_line(s, ch); } if(hostp->up == HOST_READY && hostp->features == NULL) { @@ -1669,11 +1784,11 @@ security_handle_t *sech; * The client does not support the features list, so give it an * empty one. */ - dbprintf(("%s: no feature set from host %s\n", - debug_prefix_time(NULL), hostp->hostname)); + dbprintf(_("no feature set from host %s\n"), hostp->hostname); hostp->features = am_set_default_feature_set(); } + security_close_connection(sech, hostp->hostname); /* XXX what about disks that only got some estimates... do we care? */ /* XXX amanda 2.1 treated that case as a bad msg */ @@ -1700,47 +1815,46 @@ security_handle_t *sech; if(est(dp)->level[0] == -1) continue; /* ignore this disk */ + qname = quote_string(dp->name); if(pkt->type == P_PREP) { - fprintf(stderr,"%s: time %s: got partial result for host %s disk %s:", + g_fprintf(stderr,_("%s: time %s: got partial result for host %s disk %s:"), get_pname(), walltime_str(curclock()), - dp->host->hostname, dp->name); - fprintf(stderr," %d -> %ldK, %d -> %ldK, %d -> %ldK\n", - est(dp)->level[0], est(dp)->est_size[0], - est(dp)->level[1], est(dp)->est_size[1], - est(dp)->level[2], est(dp)->est_size[2]); + dp->host->hostname, qname); + g_fprintf(stderr,_(" %d -> %lldK, %d -> %lldK, %d -> %lldK\n"), + est(dp)->level[0], (long long)est(dp)->est_size[0], + est(dp)->level[1], (long long)est(dp)->est_size[1], + est(dp)->level[2], (long long)est(dp)->est_size[2]); enqueue_disk(&pestq, dp); } else if(pkt->type == P_REP) { - fprintf(stderr,"%s: time %s: got result for host %s disk %s:", + g_fprintf(stderr,_("%s: time %s: got result for host %s disk %s:"), get_pname(), walltime_str(curclock()), - dp->host->hostname, dp->name); - fprintf(stderr," %d -> %ldK, %d -> %ldK, %d -> %ldK\n", - est(dp)->level[0], est(dp)->est_size[0], - est(dp)->level[1], est(dp)->est_size[1], - est(dp)->level[2], est(dp)->est_size[2]); - if((est(dp)->level[0] != -1 && est(dp)->est_size[0] > 0) || - (est(dp)->level[1] != -1 && est(dp)->est_size[1] > 0) || - (est(dp)->level[2] != -1 && est(dp)->est_size[2] > 0)) { - - if(est(dp)->level[2] != -1 && est(dp)->est_size[2] < 0) { + dp->host->hostname, qname); + g_fprintf(stderr,_(" %d -> %lldK, %d -> %lldK, %d -> %lldK\n"), + est(dp)->level[0], (long long)est(dp)->est_size[0], + est(dp)->level[1], (long long)est(dp)->est_size[1], + est(dp)->level[2], (long long)est(dp)->est_size[2]); + if((est(dp)->level[0] != -1 && est(dp)->est_size[0] > (off_t)0) || + (est(dp)->level[1] != -1 && est(dp)->est_size[1] > (off_t)0) || + (est(dp)->level[2] != -1 && est(dp)->est_size[2] > (off_t)0)) { + + if(est(dp)->level[2] != -1 && est(dp)->est_size[2] < (off_t)0) { log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, - est(dp)->level[2]); + _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[2]); est(dp)->level[2] = -1; } - if(est(dp)->level[1] != -1 && est(dp)->est_size[1] < 0) { + if(est(dp)->level[1] != -1 && est(dp)->est_size[1] < (off_t)0) { log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, + _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[1]); est(dp)->level[1] = -1; } - if(est(dp)->level[0] != -1 && est(dp)->est_size[0] < 0) { + if(est(dp)->level[0] != -1 && est(dp)->est_size[0] < (off_t)0) { log_add(L_WARNING, - "disk %s:%s, estimate of level %d failed.", - dp->host->hostname, dp->name, - est(dp)->level[0]); + _("disk %s:%s, estimate of level %d failed."), + dp->host->hostname, qname, est(dp)->level[0]); est(dp)->level[0] = -1; } enqueue_disk(&estq, dp); @@ -1748,61 +1862,58 @@ security_handle_t *sech; else { enqueue_disk(&failq, dp); if(est(dp)->got_estimate) { - est(dp)->errstr = vstralloc("disk ", dp->name, - ", all estimate failed", NULL); + est(dp)->errstr = vstrallocf("disk %s, all estimate failed", + qname); } else { - fprintf(stderr, "error result for host %s disk %s: missing estimate\n", - dp->host->hostname, dp->name); - est(dp)->errstr = vstralloc("missing result for ", dp->name, - " in ", dp->host->hostname, - " response", - NULL); + g_fprintf(stderr, + _("error result for host %s disk %s: missing estimate\n"), + dp->host->hostname, qname); + if (est(dp)->errstr == NULL) { + est(dp)->errstr = vstrallocf(_("missing result for %s in %s response"), + qname, dp->host->hostname); + } } } } + amfree(qname); } getsize(hostp); + /* try to clean up any defunct processes, since Amanda doesn't wait() for + them explicitly */ + while(waitpid(-1, NULL, WNOHANG)> 0); return; NAK_parse_failed: - /* msgdisk_undo is always NULL */ - /* if(msgdisk_undo) { */ - /* *msgdisk_undo = msgdisk_undo_ch; */ - /* msgdisk_undo = NULL; */ - /* } */ - errbuf = stralloc2(hostp->hostname, " NAK: [NAK parse failed]"); - fprintf(stderr, "got strange nak from %s:\n----\n%s----\n\n", + errbuf = vstrallocf(_("%s NAK: [NAK parse failed]"), hostp->hostname); + g_fprintf(stderr, _("got strange nak from %s:\n----\n%s----\n\n"), hostp->hostname, pkt->body); goto error_return; bad_msg: - - if(msgdisk_undo) { - *msgdisk_undo = msgdisk_undo_ch; - msgdisk_undo = NULL; - } - fprintf(stderr,"got a bad message, stopped at:\n"); - fprintf(stderr,"----\n%s----\n\n", line); - errbuf = stralloc2("badly formatted response from ", hostp->hostname); - /* fall through to ... */ + g_fprintf(stderr,_("got a bad message, stopped at:\n")); + /*@ignore@*/ + g_fprintf(stderr,_("----\n%s----\n\n"), line); + errbuf = stralloc2(_("badly formatted response from "), hostp->hostname); + /*@end@*/ error_return: - i = 0; for(dp = hostp->disks; dp != NULL; dp = dp->hostnext) { - if(est(dp)->state != DISK_ACTIVE) continue; - est(dp)->state = DISK_DONE; - if(est(dp)->state == DISK_ACTIVE) { - est(dp)->state = DISK_DONE; - remove_disk(&waitq, dp); - enqueue_disk(&failq, dp); - i++; + if (dp->todo) { + if(est(dp)->state == DISK_ACTIVE) { + qname = quote_string(dp->name); + est(dp)->state = DISK_DONE; + remove_disk(&waitq, dp); + enqueue_disk(&failq, dp); + i++; - est(dp)->errstr = stralloc(errbuf); - fprintf(stderr, "error result for host %s disk %s: %s\n", - dp->host->hostname, dp->name, errbuf); + est(dp)->errstr = stralloc(errbuf); + g_fprintf(stderr, _("error result for host %s disk %s: %s\n"), + dp->host->hostname, qname, errbuf); + amfree(qname); + } } } if(i == 0) { @@ -1814,6 +1925,9 @@ security_handle_t *sech; } hostp->up = HOST_DONE; amfree(errbuf); + /* try to clean up any defunct processes, since Amanda doesn't wait() for + them explicitly */ + while(waitpid(-1, NULL, WNOHANG)> 0); } @@ -1825,21 +1939,22 @@ security_handle_t *sech; * */ -static int schedule_order P((disk_t *a, disk_t *b)); /* subroutines */ -static int pick_inclevel P((disk_t *dp)); +static int schedule_order(disk_t *a, disk_t *b); /* subroutines */ +static int pick_inclevel(disk_t *dp); -static void analyze_estimate(dp) -disk_t *dp; +static void analyze_estimate( + disk_t *dp) { est_t *ep; info_t info; int have_info = 0; + char *qname = quote_string(dp->name); ep = est(dp); - fprintf(stderr, "pondering %s:%s... ", - dp->host->hostname, dp->name); - fprintf(stderr, "next_level0 %d last_level %d ", + g_fprintf(stderr, _("pondering %s:%s... "), + dp->host->hostname, qname); + g_fprintf(stderr, _("next_level0 %d last_level %d "), ep->next_level0, ep->last_level); if(get_info(dp->host->hostname, dp->name, &info) == 0) { @@ -1847,190 +1962,190 @@ disk_t *dp; } ep->degr_level = -1; - ep->degr_size = -1; + ep->degr_nsize = (off_t)-1; + ep->degr_csize = (off_t)-1; - if(ep->next_level0 <= 0 - || (have_info && ep->last_level == 0 && (info.command & FORCE_NO_BUMP))) { + if(ep->next_level0 <= 0 || (have_info && ep->last_level == 0 + && (info.command & FORCE_NO_BUMP))) { if(ep->next_level0 <= 0) { - fprintf(stderr,"(due for level 0) "); + g_fprintf(stderr,_("(due for level 0) ")); } ep->dump_level = 0; - ep->dump_size = est_tape_size(dp, 0); - if(ep->dump_size <= 0) { - fprintf(stderr, - "(no estimate for level 0, picking an incr level)\n"); + ep->dump_nsize = est_size(dp, 0); + ep->dump_csize = est_tape_size(dp, 0); + if(ep->dump_csize <= (off_t)0) { + g_fprintf(stderr, + _("(no estimate for level 0, picking an incr level)\n")); ep->dump_level = pick_inclevel(dp); - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); - if(ep->dump_size == -1) { + if(ep->dump_nsize == (off_t)-1) { ep->dump_level = ep->dump_level + 1; - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); } } else { - total_lev0 += (double) ep->dump_size; + total_lev0 += (double) ep->dump_csize; if(ep->last_level == -1 || dp->skip_incr) { - fprintf(stderr,"(%s disk, can't switch to degraded mode)\n", - dp->skip_incr? "skip-incr":"new"); + g_fprintf(stderr,_("(%s disk, can't switch to degraded mode)\n"), + dp->skip_incr? "skip-incr":_("new")); ep->degr_level = -1; - ep->degr_size = -1; + ep->degr_nsize = (off_t)-1; + ep->degr_csize = (off_t)-1; } else { /* fill in degraded mode info */ - fprintf(stderr,"(picking inclevel for degraded mode)"); + g_fprintf(stderr,_("(picking inclevel for degraded mode)")); ep->degr_level = pick_inclevel(dp); - ep->degr_size = est_tape_size(dp, ep->degr_level); - if(ep->degr_size == -1) { + ep->degr_nsize = est_size(dp, ep->degr_level); + ep->degr_csize = est_tape_size(dp, ep->degr_level); + if(ep->degr_csize == (off_t)-1) { ep->degr_level = ep->degr_level + 1; - ep->degr_size = est_tape_size(dp, ep->degr_level); + ep->degr_nsize = est_size(dp, ep->degr_level); + ep->degr_csize = est_tape_size(dp, ep->degr_level); } - if(ep->degr_size == -1) { - fprintf(stderr,"(no inc estimate)"); + if(ep->degr_csize == (off_t)-1) { + g_fprintf(stderr,_("(no inc estimate)")); ep->degr_level = -1; } - fprintf(stderr,"\n"); + g_fprintf(stderr,"\n"); } } } else { - fprintf(stderr,"(not due for a full dump, picking an incr level)\n"); + g_fprintf(stderr,_("(not due for a full dump, picking an incr level)\n")); /* XXX - if this returns -1 may be we should force a total? */ ep->dump_level = pick_inclevel(dp); - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); - if(ep->dump_size == -1) { + if(ep->dump_csize == (off_t)-1) { ep->dump_level = ep->last_level; - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); } - if(ep->dump_size == -1) { + if(ep->dump_csize == (off_t)-1) { ep->dump_level = ep->last_level + 1; - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); } - if(ep->dump_size == -1) { + if(ep->dump_csize == (off_t)-1) { ep->dump_level = 0; - ep->dump_size = est_tape_size(dp, ep->dump_level); + ep->dump_nsize = est_size(dp, ep->dump_level); + ep->dump_csize = est_tape_size(dp, ep->dump_level); } } - fprintf(stderr," curr level %d size %ld ", ep->dump_level, ep->dump_size); + g_fprintf(stderr,_(" curr level %d nsize %lld csize %lld "), + ep->dump_level, (long long)ep->dump_nsize, + (long long)ep->dump_csize); insert_disk(&schedq, dp, schedule_order); - total_size += tt_blocksize_kb + ep->dump_size + tape_mark; + total_size += (off_t)tt_blocksize_kb + ep->dump_csize + tape_mark; /* update the balanced size */ if(!(dp->skip_full || dp->strategy == DS_NOFULL || dp->strategy == DS_INCRONLY)) { - long lev0size; + off_t lev0size; lev0size = est_tape_size(dp, 0); - if(lev0size == -1) lev0size = ep->last_lev0size; + if(lev0size == (off_t)-1) lev0size = ep->last_lev0size; - balanced_size += lev0size / runs_per_cycle; + balanced_size += (double)(lev0size / (off_t)runs_per_cycle); } - fprintf(stderr,"total size " AM64_FMT " total_lev0 %1.0f balanced-lev0size %1.0f\n", - total_size, total_lev0, balanced_size); + g_fprintf(stderr,_("total size %lld total_lev0 %1.0lf balanced-lev0size %1.0lf\n"), + (long long)total_size, total_lev0, balanced_size); + amfree(qname); } -static void handle_failed(dp) -disk_t *dp; +static void handle_failed( + disk_t *dp) { - char *errstr; + char *errstr, *errstr1, *qerrstr; + char *qname = quote_string(dp->name); -/* - * From George Scott : - * -------- - * If a machine is down when the planner is run it guesses from historical - * data what the size of tonights dump is likely to be and schedules a - * dump anyway. The dumper then usually discovers that that machine is - * still down and ends up with a half full tape. Unfortunately the - * planner had to delay another dump because it thought that the tape was - * full. The fix here is for the planner to ignore unavailable machines - * rather than ignore the fact that they are unavailable. - * -------- - */ + errstr = est(dp)->errstr? est(dp)->errstr : _("hmm, no error indicator!"); + errstr1 = vstralloc("[",errstr,"]", NULL); + qerrstr = quote_string(errstr1); + amfree(errstr1); -#ifdef old_behavior - if(est(dp)->last_level != -1) { - log_add(L_WARNING, - "Could not get estimate for %s:%s, using historical data.", - dp->host->hostname, dp->name); - analyze_estimate(dp); - return; - } -#endif - - errstr = est(dp)->errstr? est(dp)->errstr : "hmm, no error indicator!"; - - fprintf(stderr, "%s: FAILED %s %s %s 0 [%s]\n", - get_pname(), dp->host->hostname, dp->name, datestamp, errstr); + g_fprintf(stderr, _("%s: FAILED %s %s %s 0 %s\n"), + get_pname(), dp->host->hostname, qname, planner_timestamp, qerrstr); - log_add(L_FAIL, "%s %s %s 0 [%s]", dp->host->hostname, dp->name, - datestamp, errstr); + log_add(L_FAIL, _("%s %s %s 0 %s"), dp->host->hostname, qname, + planner_timestamp, qerrstr); + amfree(qerrstr); + amfree(qname); /* XXX - memory leak with *dp */ } -static int schedule_order(a, b) -disk_t *a, *b; /* * insert-sort by decreasing priority, then * by decreasing size within priority levels. */ + +static int schedule_order( + disk_t *a, + disk_t *b) { int diff; - long ldiff; + off_t ldiff; diff = est(b)->dump_priority - est(a)->dump_priority; if(diff != 0) return diff; - ldiff = est(b)->dump_size - est(a)->dump_size; - if(ldiff < 0) return -1; /* XXX - there has to be a better way to dothis */ - if(ldiff > 0) return 1; + ldiff = est(b)->dump_csize - est(a)->dump_csize; + if(ldiff < (off_t)0) return -1; /* XXX - there has to be a better way to dothis */ + if(ldiff > (off_t)0) return 1; return 0; } -static int pick_inclevel(dp) -disk_t *dp; +static int pick_inclevel( + disk_t *dp) { int base_level, bump_level; - long base_size, bump_size; - long thresh; + off_t base_size, bump_size; + off_t thresh; + char *qname; base_level = est(dp)->last_level; /* if last night was level 0, do level 1 tonight, no ifs or buts */ if(base_level == 0) { - fprintf(stderr," picklev: last night 0, so tonight level 1\n"); + g_fprintf(stderr,_(" picklev: last night 0, so tonight level 1\n")); return 1; } /* if no-full option set, always do level 1 */ if(dp->strategy == DS_NOFULL) { - fprintf(stderr," picklev: no-full set, so always level 1\n"); + g_fprintf(stderr,_(" picklev: no-full set, so always level 1\n")); return 1; } base_size = est_size(dp, base_level); /* if we didn't get an estimate, we can't do an inc */ - if(base_size == -1) { + if(base_size == (off_t)-1) { base_size = est_size(dp, base_level+1); - if(base_size > 0) /* FORCE_BUMP */ + if(base_size > (off_t)0) /* FORCE_BUMP */ return base_level+1; - fprintf(stderr," picklev: no estimate for level %d, so no incs\n", base_level); + g_fprintf(stderr,_(" picklev: no estimate for level %d, so no incs\n"), base_level); return base_level; } thresh = bump_thresh(base_level, est_size(dp, 0), dp->bumppercent, dp->bumpsize, dp->bumpmult); - fprintf(stderr, - " pick: size %ld level %d days %d (thresh %ldK, %d days)\n", - base_size, base_level, est(dp)->level_days, - thresh, dp->bumpdays); + g_fprintf(stderr, + _(" pick: size %lld level %d days %d (thresh %lldK, %d days)\n"), + (long long)base_size, base_level, est(dp)->level_days, + (long long)thresh, dp->bumpdays); if(base_level == 9 || est(dp)->level_days < dp->bumpdays @@ -2040,18 +2155,21 @@ disk_t *dp; bump_level = base_level + 1; bump_size = est_size(dp, bump_level); - if(bump_size == -1) return base_level; + if(bump_size == (off_t)-1) return base_level; - fprintf(stderr, " pick: next size %ld... ", bump_size); + g_fprintf(stderr, _(" pick: next size %lld... "), + (long long)bump_size); if(base_size - bump_size < thresh) { - fprintf(stderr, "not bumped\n"); + g_fprintf(stderr, _("not bumped\n")); return base_level; } - fprintf(stderr, "BUMPED\n"); - log_add(L_INFO, "Incremental of %s:%s bumped to level %d.", - dp->host->hostname, dp->name, bump_level); + qname = quote_string(dp->name); + g_fprintf(stderr, _("BUMPED\n")); + log_add(L_INFO, _("Incremental of %s:%s bumped to level %d."), + dp->host->hostname, qname, bump_level); + amfree(qname); return bump_level; } @@ -2083,19 +2201,25 @@ disk_t *dp; ** more balanced cycle. */ -static void delay_one_dump P((disk_t *dp, int delete, ...)); +static void delay_one_dump(disk_t *dp, int delete, ...); +static int promote_highest_priority_incremental(void); +static int promote_hills(void); -static void delay_dumps P((void)) /* delay any dumps that will not fit */ +static void delay_dumps(void) { - disk_t *dp, *ndp, *preserve; - bi_t *bi, *nbi; - am64_t new_total; /* New total_size */ - char est_kb[20]; /* Text formatted dump size */ - int nb_forced_level_0; - info_t info; - int delete; - char *message; + disk_t * dp; + disk_t * ndp; + disk_t * preserve; + bi_t * bi; + bi_t * nbi; + off_t new_total; /* New total_size */ + char est_kb[20]; /* Text formatted dump size */ + int nb_forced_level_0; + info_t info; + int delete; + char * message; + off_t full_size; biq.head = biq.tail = NULL; @@ -2112,47 +2236,64 @@ static void delay_dumps P((void)) for(dp = schedq.head; dp != NULL; dp = ndp) { int avail_tapes = 1; - if (dp->tape_splitsize > 0) + if (dp->tape_splitsize > (off_t)0) avail_tapes = conf_runtapes; ndp = dp->next; /* remove_disk zaps this */ - if (est(dp)->dump_size == -1 || - est(dp)->dump_size <= tape->length * avail_tapes) { + full_size = est_tape_size(dp, 0); + if (full_size > tapetype_get_length(tape) * (off_t)avail_tapes) { + char *qname = quote_string(dp->name); + if (conf_runtapes > 1 && dp->tape_splitsize == (off_t)0) { + log_add(L_WARNING, _("disk %s:%s, full dump (%lldKB) will be larger than available tape space" + ", you could define a splitsize"), + dp->host->hostname, qname, + (long long)full_size); + } else { + log_add(L_WARNING, _("disk %s:%s, full dump (%lldKB) will be larger than available tape space"), + dp->host->hostname, qname, + (long long)full_size); + } + amfree(qname); + } + + if (est(dp)->dump_csize == (off_t)-1 || + est(dp)->dump_csize <= tapetype_get_length(tape) * (off_t)avail_tapes) { continue; } - /* Format dumpsize for messages */ - snprintf(est_kb, 20, "%ld KB,", est(dp)->dump_size); + /* Format dumpsize for messages */ + g_snprintf(est_kb, 20, "%lld KB,", + (long long)est(dp)->dump_csize); if(est(dp)->dump_level == 0) { if(dp->skip_incr) { delete = 1; - message = "but cannot incremental dump skip-incr disk"; + message = _("but cannot incremental dump skip-incr disk"); } else if(est(dp)->last_level < 0) { delete = 1; - message = "but cannot incremental dump new disk"; + message = _("but cannot incremental dump new disk"); } else if(est(dp)->degr_level < 0) { delete = 1; - message = "but no incremental estimate"; + message = _("but no incremental estimate"); } - else if (est(dp)->degr_size > tape->length) { + else if (est(dp)->degr_csize > tapetype_get_length(tape)) { delete = 1; - message = "incremental dump also larger than tape"; + message = _("incremental dump also larger than tape"); } else { delete = 0; - message = "full dump delayed"; + message = _("full dump delayed"); } } else { delete = 1; - message = "skipping incremental"; + message = _("skipping incremental"); } - delay_one_dump(dp, delete, "dump larger than available tape space,", est_kb, - message, NULL); + delay_one_dump(dp, delete, _("dump larger than available tape space,"), + est_kb, message, NULL); } /* @@ -2191,26 +2332,27 @@ static void delay_dumps P((void)) if(dp != preserve) { - /* Format dumpsize for messages */ - snprintf(est_kb, 20, "%ld KB,", est(dp)->dump_size); + /* Format dumpsize for messages */ + g_snprintf(est_kb, 20, "%lld KB,", + (long long)est(dp)->dump_csize); if(dp->skip_incr) { delete = 1; - message = "but cannot incremental dump skip-incr disk"; + message = _("but cannot incremental dump skip-incr disk"); } else if(est(dp)->last_level < 0) { delete = 1; - message = "but cannot incremental dump new disk"; + message = _("but cannot incremental dump new disk"); } else if(est(dp)->degr_level < 0) { delete = 1; - message = "but no incremental estimate"; + message = _("but no incremental estimate"); } else { delete = 0; - message = "full dump delayed"; + message = _("full dump delayed"); } - delay_one_dump(dp, delete, "dumps too big,", est_kb, + delay_one_dump(dp, delete, _("dumps too big,"), est_kb, message, NULL); } } @@ -2225,25 +2367,26 @@ static void delay_dumps P((void)) if(est(dp)->dump_level == 0 && dp != preserve) { /* Format dumpsize for messages */ - snprintf(est_kb, 20, "%ld KB,", est(dp)->dump_size); + g_snprintf(est_kb, 20, "%lld KB,", + (long long)est(dp)->dump_csize); if(dp->skip_incr) { delete = 1; - message = "but cannot incremental dump skip-incr disk"; + message = _("but cannot incremental dump skip-incr disk"); } else if(est(dp)->last_level < 0) { delete = 1; - message = "but cannot incremental dump new disk"; + message = _("but cannot incremental dump new disk"); } else if(est(dp)->degr_level < 0) { delete = 1; - message = "but no incremental estimate"; + message = _("but no incremental estimate"); } else { delete = 0; - message = "full dump delayed"; + message = _("full dump delayed"); } - delay_one_dump(dp, delete, "dumps too big,", est_kb, + delay_one_dump(dp, delete, _("dumps too big,"), est_kb, message, NULL); } } @@ -2264,13 +2407,14 @@ static void delay_dumps P((void)) if(est(dp)->dump_level != 0) { - /* Format dumpsize for messages */ - snprintf(est_kb, 20, "%ld KB,", est(dp)->dump_size); + /* Format dumpsize for messages */ + g_snprintf(est_kb, 20, "%lld KB,", + (long long)est(dp)->dump_csize); delay_one_dump(dp, 1, - "dumps way too big,", + _("dumps way too big,"), est_kb, - "must skip incremental dumps", + _("must skip incremental dumps"), NULL); } } @@ -2284,29 +2428,33 @@ static void delay_dumps P((void)) ** in but why complicate the code? */ - for(bi = biq.tail; bi != NULL; bi = nbi) { +/*@i@*/ for(bi = biq.tail; bi != NULL; bi = nbi) { int avail_tapes = 1; nbi = bi->prev; dp = bi->dp; - if(dp->tape_splitsize > 0) avail_tapes = conf_runtapes; - - if(bi->deleted) - new_total = total_size + tt_blocksize_kb + bi->size + tape_mark; - else - new_total = total_size - est(dp)->dump_size + bi->size; + if(dp->tape_splitsize > (off_t)0) + avail_tapes = conf_runtapes; - if(new_total <= tape_length && bi->size < tape->length * avail_tapes) { + if(bi->deleted) { + new_total = total_size + (off_t)tt_blocksize_kb + + bi->csize + (off_t)tape_mark; + } else { + new_total = total_size - est(dp)->dump_csize + bi->csize; + } + if((new_total <= tape_length) && + (bi->csize < (tapetype_get_length(tape) * (off_t)avail_tapes))) { /* reinstate it */ total_size = new_total; if(bi->deleted) { if(bi->level == 0) { - total_lev0 += (double) bi->size; + total_lev0 += (double) bi->csize; } insert_disk(&schedq, dp, schedule_order); } else { est(dp)->dump_level = bi->level; - est(dp)->dump_size = bi->size; + est(dp)->dump_nsize = bi->nsize; + est(dp)->dump_csize = bi->csize; } /* Keep it clean */ @@ -2318,6 +2466,7 @@ static void delay_dumps P((void)) biq.head = bi->next; else (bi->prev)->next = bi->next; + amfree(bi->errstr); amfree(bi); } @@ -2331,26 +2480,26 @@ static void delay_dumps P((void)) ** now. */ - for(bi = biq.head; bi != NULL; bi = nbi) { +/*@i@*/ for(bi = biq.head; bi != NULL; bi = nbi) { nbi = bi->next; - if(bi->deleted) { - fprintf(stderr, "%s: FAILED %s\n", get_pname(), bi->errstr); + g_fprintf(stderr, "%s: FAILED %s\n", get_pname(), bi->errstr); log_add(L_FAIL, "%s", bi->errstr); } else { dp = bi->dp; - fprintf(stderr, " delay: %s now at level %d\n", + g_fprintf(stderr, _(" delay: %s now at level %d\n"), bi->errstr, est(dp)->dump_level); log_add(L_INFO, "%s", bi->errstr); } - - /* Clean up - dont be too fancy! */ + /*@ignore@*/ amfree(bi->errstr); amfree(bi); + /*@end@*/ } - fprintf(stderr, " delay: Total size now " AM64_FMT ".\n", total_size); + g_fprintf(stderr, _(" delay: Total size now %lld.\n"), + (long long)total_size); return; } @@ -2360,24 +2509,27 @@ static void delay_dumps P((void)) * Remove a dump or modify it from full to incremental. * Keep track of it on the bi q in case we can add it back later. */ -arglist_function1(static void delay_one_dump, - disk_t *, dp, - int, delete) +arglist_function1( + static void delay_one_dump, + disk_t *, dp, + int, delete) { bi_t *bi; va_list argp; char level_str[NUM_STR_SIZE]; char *sep; char *next; + char *qname = quote_string(dp->name); + char *errstr, *qerrstr; arglist_start(argp, delete); - total_size -= tt_blocksize_kb + est(dp)->dump_size + tape_mark; + total_size -= (off_t)tt_blocksize_kb + est(dp)->dump_csize + (off_t)tape_mark; if(est(dp)->dump_level == 0) { - total_lev0 -= (double) est(dp)->dump_size; + total_lev0 -= (double) est(dp)->dump_csize; } - bi = alloc(sizeof(bi_t)); + bi = alloc(SIZEOF(bi_t)); bi->next = NULL; bi->prev = biq.tail; if(biq.tail == NULL) @@ -2389,41 +2541,49 @@ arglist_function1(static void delay_one_dump, bi->deleted = delete; bi->dp = dp; bi->level = est(dp)->dump_level; - bi->size = est(dp)->dump_size; + bi->nsize = est(dp)->dump_nsize; + bi->csize = est(dp)->dump_csize; - snprintf(level_str, sizeof(level_str), "%d", est(dp)->dump_level); + g_snprintf(level_str, SIZEOF(level_str), "%d", est(dp)->dump_level); bi->errstr = vstralloc(dp->host->hostname, - " ", dp->name, - " ", datestamp ? datestamp : "?", + " ", qname, + " ", planner_timestamp ? planner_timestamp : "?", " ", level_str, NULL); - sep = " ["; + errstr = NULL; + sep = "["; while ((next = arglist_val(argp, char *)) != NULL) { - bi->errstr = newvstralloc(bi->errstr, bi->errstr, sep, next, NULL); + vstrextend(&errstr, sep, next, NULL); sep = " "; } - strappend(bi->errstr, "]"); + strappend(errstr, "]"); + qerrstr = quote_string(errstr); + vstrextend(&bi->errstr, " ", qerrstr); + amfree(errstr); + amfree(qerrstr); arglist_end(argp); if (delete) { remove_disk(&schedq, dp); } else { est(dp)->dump_level = est(dp)->degr_level; - est(dp)->dump_size = est(dp)->degr_size; - total_size += tt_blocksize_kb + est(dp)->dump_size + tape_mark; + est(dp)->dump_nsize = est(dp)->degr_nsize; + est(dp)->dump_csize = est(dp)->degr_csize; + total_size += (off_t)tt_blocksize_kb + est(dp)->dump_csize + (off_t)tape_mark; } - + amfree(qname); return; } -static int promote_highest_priority_incremental P((void)) +static int promote_highest_priority_incremental(void) { disk_t *dp, *dp1, *dp_promote; - long new_size, new_total, new_lev0; + off_t new_size, new_total, new_lev0; int check_days; int nb_today, nb_same_day, nb_today2; int nb_disk_today, nb_disk_same_day; + char *qname; /* * return 1 if did so; must update total_size correctly; must not @@ -2435,7 +2595,7 @@ static int promote_highest_priority_incremental P((void)) est(dp)->promote = -1000; - if(est_size(dp,0) <= 0) + if(est_size(dp,0) <= (off_t)0) continue; if(est(dp)->next_level0 <= 0) @@ -2445,14 +2605,14 @@ static int promote_highest_priority_incremental P((void)) continue; new_size = est_tape_size(dp, 0); - new_total = total_size - est(dp)->dump_size + new_size; - new_lev0 = total_lev0 + new_size; + new_total = total_size - est(dp)->dump_csize + new_size; + new_lev0 = (off_t)total_lev0 + new_size; nb_today = 0; nb_same_day = 0; nb_disk_today = 0; nb_disk_same_day = 0; - for(dp1 = schedq.head; dp1 != NULL; dp1 = dp1->next) { + for(dp1 = schedq.head; dp1 != NULL; dp1 = dp1->next) { if(est(dp1)->dump_level == 0) nb_disk_today++; else if(est(dp1)->next_level0 == est(dp)->next_level0) @@ -2466,18 +2626,22 @@ static int promote_highest_priority_incremental P((void)) } /* do not promote if overflow tape */ - if(new_total > tape_length) continue; + if(new_total > tape_length) + continue; /* do not promote if overflow balanced size and something today */ /* promote if nothing today */ - if(new_lev0 > balanced_size+balance_threshold && nb_disk_today > 0) + if((new_lev0 > (off_t)(balanced_size + balance_threshold)) && + (nb_disk_today > 0)) continue; /* do not promote if only one disk due that day and nothing today */ - if(nb_disk_same_day == 1 && nb_disk_today == 0) continue; + if(nb_disk_same_day == 1 && nb_disk_today == 0) + continue; nb_today2 = nb_today*nb_today; - if(nb_today == 0 && nb_same_day > 1) nb_same_day++; + if(nb_today == 0 && nb_same_day > 1) + nb_same_day++; if(nb_same_day >= nb_today2) { est(dp)->promote = ((nb_same_day - nb_today2)*(nb_same_day - nb_today2)) + @@ -2488,61 +2652,69 @@ static int promote_highest_priority_incremental P((void)) conf_dumpcycle - est(dp)->next_level0; } - if(!dp_promote || est(dp_promote)->promote < est(dp)->promote) { + qname = quote_string(dp->name); + if(!dp_promote || est(dp_promote)->promote < est(dp)->promote) { dp_promote = dp; - fprintf(stderr," try %s:%s %d %d %d = %d\n", - dp->host->hostname, dp->name, nb_same_day, nb_today, est(dp)->next_level0, est(dp)->promote); + g_fprintf(stderr," try %s:%s %d %d %d = %d\n", + dp->host->hostname, qname, nb_same_day, nb_today, est(dp)->next_level0, est(dp)->promote); } - else { - fprintf(stderr,"no try %s:%s %d %d %d = %d\n", - dp->host->hostname, dp->name, nb_same_day, nb_today, est(dp)->next_level0, est(dp)->promote); + else { + g_fprintf(stderr,"no try %s:%s %d %d %d = %d\n", + dp->host->hostname, qname, nb_same_day, nb_today, est(dp)->next_level0, est(dp)->promote); } + amfree(qname); } if(dp_promote) { dp = dp_promote; + qname = quote_string(dp->name); new_size = est_tape_size(dp, 0); - new_total = total_size - est(dp)->dump_size + new_size; - new_lev0 = total_lev0 + new_size; + new_total = total_size - est(dp)->dump_csize + new_size; + new_lev0 = (off_t)total_lev0 + new_size; total_size = new_total; - total_lev0 = new_lev0; + total_lev0 = (double)new_lev0; check_days = est(dp)->next_level0; est(dp)->degr_level = est(dp)->dump_level; - est(dp)->degr_size = est(dp)->dump_size; + est(dp)->degr_nsize = est(dp)->dump_nsize; + est(dp)->degr_csize = est(dp)->dump_csize; est(dp)->dump_level = 0; - est(dp)->dump_size = new_size; + est(dp)->dump_nsize = est_size(dp, 0); + est(dp)->dump_csize = new_size; est(dp)->next_level0 = 0; - fprintf(stderr, - " promote: moving %s:%s up, total_lev0 %1.0f, total_size " AM64_FMT "\n", - dp->host->hostname, dp->name, - total_lev0, total_size); + g_fprintf(stderr, + _(" promote: moving %s:%s up, total_lev0 %1.0lf, total_size %lld\n"), + dp->host->hostname, qname, + total_lev0, (long long)total_size); log_add(L_INFO, - "Full dump of %s:%s promoted from %d day%s ahead.", - dp->host->hostname, dp->name, - check_days, (check_days == 1) ? "" : "s"); + plural(_("Full dump of %s:%s promoted from %d day ahead."), + _("Full dump of %s:%s promoted from %d days ahead."), + check_days), + dp->host->hostname, qname, check_days); + amfree(qname); return 1; } return 0; } -static int promote_hills P((void)) +static int promote_hills(void) { disk_t *dp; struct balance_stats { int disks; - long size; + off_t size; } *sp = NULL; int days; int hill_days = 0; - long hill_size; - long new_size; - long new_total; + off_t hill_size; + off_t new_size; + off_t new_total; int my_dumpcycle; + char *qname; /* If we are already doing a level 0 don't bother */ if(total_lev0 > 0) @@ -2553,10 +2725,12 @@ static int promote_hills P((void)) if(my_dumpcycle > 10000) my_dumpcycle = 10000; sp = (struct balance_stats *) - alloc(sizeof(struct balance_stats) * my_dumpcycle); + alloc(SIZEOF(struct balance_stats) * my_dumpcycle); - for(days = 0; days < my_dumpcycle; days++) - sp[days].disks = sp[days].size = 0; + for(days = 0; days < my_dumpcycle; days++) { + sp[days].disks = 0; + sp[days].size = (off_t)0; + } for(dp = schedq.head; dp != NULL; dp = dp->next) { days = est(dp)->next_level0; /* This is > 0 by definition */ @@ -2570,7 +2744,7 @@ static int promote_hills P((void)) /* Search for a suitable big hill and cut it down */ while(1) { /* Find the tallest hill */ - hill_size = 0; + hill_size = (off_t)0; for(days = 0; days < my_dumpcycle; days++) { if(sp[days].disks > 1 && sp[days].size > hill_size) { hill_size = sp[days].size; @@ -2578,7 +2752,7 @@ static int promote_hills P((void)) } } - if(hill_size <= 0) break; /* no suitable hills */ + if(hill_size <= (off_t)0) break; /* no suitable hills */ /* Find all the dumps in that hill and try and remove one */ for(dp = schedq.head; dp != NULL; dp = dp->next) { @@ -2589,28 +2763,33 @@ static int promote_hills P((void)) dp->strategy == DS_INCRONLY) continue; new_size = est_tape_size(dp, 0); - new_total = total_size - est(dp)->dump_size + new_size; + new_total = total_size - est(dp)->dump_csize + new_size; if(new_total > tape_length) continue; /* We found a disk we can promote */ + qname = quote_string(dp->name); total_size = new_total; - total_lev0 += new_size; + total_lev0 += (double)new_size; est(dp)->degr_level = est(dp)->dump_level; - est(dp)->degr_size = est(dp)->dump_size; + est(dp)->degr_nsize = est(dp)->dump_nsize; + est(dp)->degr_csize = est(dp)->dump_csize; est(dp)->dump_level = 0; est(dp)->next_level0 = 0; - est(dp)->dump_size = new_size; + est(dp)->dump_nsize = est_size(dp, 0); + est(dp)->dump_csize = new_size; - fprintf(stderr, - " promote: moving %s:%s up, total_lev0 %1.0f, total_size " AM64_FMT "\n", - dp->host->hostname, dp->name, - total_lev0, total_size); + g_fprintf(stderr, + _(" promote: moving %s:%s up, total_lev0 %1.0lf, total_size %lld\n"), + dp->host->hostname, qname, + total_lev0, (long long)total_size); log_add(L_INFO, - "Full dump of %s:%s specially promoted from %d day%s ahead.", - dp->host->hostname, dp->name, - hill_days, (hill_days == 1) ? "" : "s"); + plural(_("Full dump of %s:%s specially promoted from %d day ahead."), + _("Full dump of %s:%s specially promoted from %d days ahead."), + hill_days), + dp->host->hostname, qname, hill_days); + amfree(qname); amfree(sp); return 1; } @@ -2628,33 +2807,40 @@ static int promote_hills P((void)) * * XXX - memory leak - we shouldn't just throw away *dp */ -static void output_scheduleline(dp) - disk_t *dp; +static void output_scheduleline( + disk_t *dp) { est_t *ep; - long dump_time = 0, degr_time = 0; + time_t dump_time = 0, degr_time = 0; + double dump_kps = 0, degr_kps = 0; char *schedline = NULL, *degr_str = NULL; char dump_priority_str[NUM_STR_SIZE]; char dump_level_str[NUM_STR_SIZE]; - char dump_size_str[NUM_STR_SIZE]; + char dump_nsize_str[NUM_STR_SIZE]; + char dump_csize_str[NUM_STR_SIZE]; char dump_time_str[NUM_STR_SIZE]; + char dump_kps_str[NUM_STR_SIZE]; char degr_level_str[NUM_STR_SIZE]; - char degr_size_str[NUM_STR_SIZE]; + char degr_nsize_str[NUM_STR_SIZE]; + char degr_csize_str[NUM_STR_SIZE]; char degr_time_str[NUM_STR_SIZE]; + char degr_kps_str[NUM_STR_SIZE]; char *dump_date, *degr_date; char *features; int i; + char *qname = quote_string(dp->name); ep = est(dp); - if(ep->dump_size == -1) { + if(ep->dump_csize == (off_t)-1) { /* no estimate, fail the disk */ - fprintf(stderr, - "%s: FAILED %s %s %s %d [no estimate]\n", + g_fprintf(stderr, + _("%s: FAILED %s %s %s %d \"[no estimate]\"\n"), get_pname(), - dp->host->hostname, dp->name, datestamp, ep->dump_level); - log_add(L_FAIL, "%s %s %s %d [no estimate]", - dp->host->hostname, dp->name, datestamp, ep->dump_level); + dp->host->hostname, qname, planner_timestamp, ep->dump_level); + log_add(L_FAIL, _("%s %s %s %d [no estimate]"), + dp->host->hostname, qname, planner_timestamp, ep->dump_level); + amfree(qname); return; } @@ -2669,47 +2855,62 @@ static void output_scheduleline(dp) #define fix_rate(rate) (rate < 1.0 ? DEFAULT_DUMPRATE : rate) if(ep->dump_level == 0) { - dump_time = ep->dump_size / fix_rate(ep->fullrate); + dump_kps = fix_rate(ep->fullrate); + dump_time = (time_t)((double)ep->dump_csize / dump_kps); - if(ep->degr_size != -1) { - degr_time = ep->degr_size / fix_rate(ep->incrrate); + if(ep->degr_csize != (off_t)-1) { + degr_kps = fix_rate(ep->incrrate); + degr_time = (time_t)((double)ep->degr_csize / degr_kps); } } else { - dump_time = ep->dump_size / fix_rate(ep->incrrate); + dump_kps = fix_rate(ep->incrrate); + dump_time = (time_t)((double)ep->dump_csize / dump_kps); } - if(ep->dump_level == 0 && ep->degr_size != -1) { - snprintf(degr_level_str, sizeof(degr_level_str), + if(ep->dump_level == 0 && ep->degr_csize != (off_t)-1) { + g_snprintf(degr_level_str, sizeof(degr_level_str), "%d", ep->degr_level); - snprintf(degr_size_str, sizeof(degr_size_str), - "%ld", ep->degr_size); - snprintf(degr_time_str, sizeof(degr_time_str), - "%ld", degr_time); + g_snprintf(degr_nsize_str, sizeof(degr_nsize_str), + "%lld", (long long)ep->degr_nsize); + g_snprintf(degr_csize_str, sizeof(degr_csize_str), + "%lld", (long long)ep->degr_csize); + g_snprintf(degr_time_str, sizeof(degr_time_str), + "%lld", (long long)degr_time); + g_snprintf(degr_kps_str, sizeof(degr_kps_str), + "%.0lf", degr_kps); degr_str = vstralloc(" ", degr_level_str, " ", degr_date, - " ", degr_size_str, + " ", degr_nsize_str, + " ", degr_csize_str, " ", degr_time_str, + " ", degr_kps_str, NULL); } - snprintf(dump_priority_str, sizeof(dump_priority_str), + g_snprintf(dump_priority_str, SIZEOF(dump_priority_str), "%d", ep->dump_priority); - snprintf(dump_level_str, sizeof(dump_level_str), + g_snprintf(dump_level_str, SIZEOF(dump_level_str), "%d", ep->dump_level); - snprintf(dump_size_str, sizeof(dump_size_str), - "%ld", ep->dump_size); - snprintf(dump_time_str, sizeof(dump_time_str), - "%ld", dump_time); + g_snprintf(dump_nsize_str, sizeof(dump_nsize_str), + "%lld", (long long)ep->dump_nsize); + g_snprintf(dump_csize_str, sizeof(dump_csize_str), + "%lld", (long long)ep->dump_csize); + g_snprintf(dump_time_str, sizeof(dump_time_str), + "%lld", (long long)dump_time); + g_snprintf(dump_kps_str, sizeof(dump_kps_str), + "%.0lf", dump_kps); features = am_feature_to_string(dp->host->features); schedline = vstralloc("DUMP ",dp->host->hostname, " ", features, - " ", dp->name, - " ", datestamp, + " ", qname, + " ", planner_timestamp, " ", dump_priority_str, " ", dump_level_str, " ", dump_date, - " ", dump_size_str, + " ", dump_nsize_str, + " ", dump_csize_str, " ", dump_time_str, + " ", dump_kps_str, degr_str ? degr_str : "", "\n", NULL); @@ -2718,4 +2919,5 @@ static void output_scheduleline(dp) amfree(features); amfree(schedline); amfree(degr_str); + amfree(qname); }