static void quota_log_bytes(struct async *as, const char *msg, uint64_t byte, uint64_t quota) { as->asfd->write_str(as->asfd, CMD_WARNING, msg); logp("Bytes estimated: %"PRIu64"%s\n", byte, bytes_to_human(byte)); logp("%s: %"PRIu64"%s\n", msg, quota, bytes_to_human(quota)); }
static void update_screen_live_counter_single(struct cntr_ent *e, int *x, int col) { char msg[128]=""; const char *bytes_human=""; if(!(e->flags & CNTR_SINGLE_FIELD)) return; if(!e->count) return; switch(e->cmd) { case CMD_TIMESTAMP: case CMD_TIMESTAMP_END: return; case CMD_BYTES_ESTIMATED: case CMD_BYTES: case CMD_BYTES_RECV: case CMD_BYTES_SENT: bytes_human=bytes_to_human(e->count); break; default: break; } snprintf(msg, sizeof(msg), "%19s: %12"PRIu64" %s", e->label, e->count, bytes_human); print_line(msg, (*x)++, col); }
static void client_summary(struct cstat *cstat, int row, int col, int clientwidth) { char msg[1024]=""; char fmt[64]=""; struct bu *cbu=NULL; snprintf(fmt, sizeof(fmt), "%%-%d.%ds %%9s %%s%%s", clientwidth, clientwidth); // Find the current backup. cbu=bu_find_current(cstat->bu); switch(cstat->run_status) { case RUN_STATUS_RUNNING: if(toggle) { char f[64]=""; char b[64]=""; uint64_t p=0; uint64_t t=0; struct cntr *cntr=cstat->cntr; struct cntr_ent *ent_gtotal= cntr->ent[(uint8_t)CMD_GRAND_TOTAL]; t=ent_gtotal->count +ent_gtotal->same +ent_gtotal->changed; if(ent_gtotal->phase1) p=(t*100)/ent_gtotal->phase1; snprintf(f, sizeof(f), " %"PRIu64"/%"PRIu64" %"PRIu64"%%", t, ent_gtotal->phase1, p); if(cntr->byte) snprintf(b, sizeof(b), "%s", bytes_to_human(cntr->byte)); snprintf(msg, sizeof(msg), fmt, cstat->name, run_status_to_str(cstat), f, b); break; } // Else fall through. case RUN_STATUS_IDLE: case RUN_STATUS_SERVER_CRASHED: case RUN_STATUS_CLIENT_CRASHED: default: snprintf(msg, sizeof(msg), fmt, cstat->name, run_status_to_str(cstat), " last backup: ", get_bu_str(cbu)); break; } if(*msg) print_line(msg, row, col); }
static void bottom_part(struct cntr *a, struct cntr *b, enum action act) { logc("\n"); logc(" Warnings: % 11llu\n", b->warning + a->warning); logc("\n"); logc(" Bytes estimated: % 11llu", a->byte); logc("%s\n", bytes_to_human(a->byte)); if(act==ACTION_ESTIMATE) return; logc(" Bytes in backup: % 11llu", b->byte); logc("%s\n", bytes_to_human(b->byte)); logc(" Bytes received: % 11llu", b->recvbyte); logc("%s\n", bytes_to_human(b->recvbyte)); logc(" Bytes sent: % 11llu", b->sentbyte); logc("%s\n", bytes_to_human(b->sentbyte)); }
void show_stat_info(char *fname, struct stat *buf) { static char mode[255]; mode_to_letters(buf->st_mode, mode); printf(" mode: %s\n", mode); /* type + mode */ printf(" links: %d\n", buf->st_nlink); /* # links */ printf(" user: %s\n", uid_to_name(buf->st_uid)); /* user name */ printf(" group: %s\n", gid_to_name(buf->st_gid)); /* group name */ printf(" size: %s\n", bytes_to_human(buf->st_size)); /* file size */ printf("accessed: %s\n", show_time((int) buf->st_atime)); /* accessed */ printf("modified: %s\n", show_time((int) buf->st_mtime)); /* modified */ printf(" changed: %s\n", show_time((int) buf->st_ctime)); /* changed */ }
static void bottom_part(struct cntr *c, enum action act) { unsigned long long l; struct cntr_ent **e=c->ent; logc("\n"); logc(" Warnings: % 11llu\n", get_count(e, CMD_WARNING)); logc("\n"); logc(" Bytes estimated: % 11llu", get_count(e, CMD_BYTES_ESTIMATED)); logc("%s\n", bytes_to_human(get_count(e, CMD_BYTES_ESTIMATED))); if(act==ACTION_ESTIMATE) return; if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED) { l=get_count(e, CMD_BYTES); logc(" Bytes in backup: % 11llu", l); logc("%s\n", bytes_to_human(l)); } if(act==ACTION_RESTORE) { l=get_count(e, CMD_BYTES); logc(" Bytes attempted: % 11llu", l); logc("%s\n", bytes_to_human(l)); } if(act==ACTION_VERIFY) { l=get_count(e, CMD_BYTES); logc(" Bytes checked: % 11llu", l); logc("%s\n", bytes_to_human(l)); } if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED) { l=get_count(e, CMD_BYTES_RECV); logc(" Bytes received: % 11llu", l); logc("%s\n", bytes_to_human(l)); } if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED || act==ACTION_RESTORE) { l=get_count(e, CMD_BYTES_SENT); logc(" Bytes sent: % 11llu", l); logc("%s\n", bytes_to_human(l)); } }
static void bottom_part(struct cntr *a, struct cntr *b, enum action act) { logc("\n"); logc(" Warnings: % 11llu\n", b->warning + a->warning); logc("\n"); logc(" Bytes estimated: % 11llu", a->byte); logc("%s\n", bytes_to_human(a->byte)); if(act==ACTION_ESTIMATE) return; if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED) { logc(" Bytes in backup: % 11llu", b->byte); logc("%s\n", bytes_to_human(b->byte)); } if(act==ACTION_RESTORE) { logc(" Bytes attempted: % 11llu", b->byte); logc("%s\n", bytes_to_human(b->byte)); } if(act==ACTION_VERIFY) { logc(" Bytes checked: % 11llu", b->byte); logc("%s\n", bytes_to_human(b->byte)); } if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED) { logc(" Bytes received: % 11llu", b->recvbyte); logc("%s\n", bytes_to_human(b->recvbyte)); } if(act==ACTION_BACKUP || act==ACTION_BACKUP_TIMED || act==ACTION_RESTORE) { logc(" Bytes sent: % 11llu", b->sentbyte); logc("%s\n", bytes_to_human(b->sentbyte)); } }
void show_stat_info_oneline(char *fname, struct stat *buf) { static char mode[255]; mode_to_letters(buf->st_mode, mode); printf("%s %d %s %s %s\t%s %s\n", mode, buf->st_nlink, uid_to_name(buf->st_uid), gid_to_name(buf->st_gid), bytes_to_human(buf->st_size), show_time((int) buf->st_mtime), fname); }
int run_bedup(int argc, char *argv[]) { int i=1; int ret=0; int option=0; int nonburp=0; unsigned int maxlinks=DEF_MAX_LINKS; char *groups=NULL; char ext[16]=""; int givenconfigfile=0; const char *configfile=NULL; configfile=get_config_path(); snprintf(ext, sizeof(ext), ".bedup.%d", getpid()); while((option=getopt(argc, argv, "c:dg:hlm:nvV?"))!=-1) { switch(option) { case 'c': configfile=optarg; givenconfigfile=1; break; case 'd': deletedups=1; break; case 'g': groups=optarg; break; case 'l': makelinks=1; break; case 'm': maxlinks=atoi(optarg); break; case 'n': nonburp=1; break; case 'V': printf("%s-%s\n", prog, VERSION); return 0; case 'v': verbose=1; break; case 'h': case '?': return usage(); } } if(nonburp && givenconfigfile) { logp("-n and -c options are mutually exclusive\n"); return 1; } if(nonburp && groups) { logp("-n and -g options are mutually exclusive\n"); return 1; } if(!nonburp && maxlinks!=DEF_MAX_LINKS) { logp("-m option is specified via the configuration file in burp mode (max_hardlinks=)\n"); return 1; } if(deletedups && makelinks) { logp("-d and -l options are mutually exclusive\n"); return 1; } if(deletedups && !nonburp) { logp("-d option requires -n option\n"); return 1; } if(optind>=argc) { if(nonburp) { logp("No directories found after options\n"); return 1; } } else { if(!nonburp) { logp("Do not specify extra arguments.\n"); return 1; } } if(maxlinks<2) { logp("The argument to -m needs to be greater than 1.\n"); return 1; } if(nonburp) { // Read directories from command line. for(i=optind; i<argc; i++) { // Strip trailing slashes, for tidiness. if(argv[i][strlen(argv[i])-1]=='/') argv[i][strlen(argv[i])-1]='\0'; if(process_dir("", argv[i], ext, maxlinks, 0 /* not burp mode */, 0 /* level */)) { ret=1; break; } } } else { struct conf **globalcs=NULL; struct strlist *grouplist=NULL; struct lock *globallock=NULL; if(groups) { char *tok=NULL; if((tok=strtok(groups, ",\n"))) { do { if(strlist_add(&grouplist, tok, 1)) { log_out_of_memory(__func__); return -1; } } while((tok=strtok(NULL, ",\n"))); } if(!grouplist) { logp("unable to read list of groups\n"); return -1; } } // Read directories from config files, and get locks. if(!(globalcs=confs_alloc())) return -1; if(confs_init(globalcs)) return -1; if(conf_load_global_only(configfile, globalcs)) return 1; if(get_e_burp_mode(globalcs[OPT_BURP_MODE])!=BURP_MODE_SERVER) { logp("%s is not a server config file\n", configfile); confs_free(&globalcs); return 1; } logp("Dedup clients from %s\n", get_string(globalcs[OPT_CLIENTCONFDIR])); maxlinks=get_int(globalcs[OPT_MAX_HARDLINKS]); if(grouplist) { struct strlist *g=NULL; logp("in dedup groups:\n"); for(g=grouplist; g; g=g->next) logp("%s\n", g->path); } else { char *lockpath=NULL; // Only get the global lock when doing a global run. // If you are doing individual groups, you are likely // to want to do many different dedup jobs and a // global lock would get in the way. if(!(lockpath=prepend( get_string(globalcs[OPT_LOCKFILE]), ".bedup", "")) || !(globallock=lock_alloc_and_init(lockpath))) return 1; lock_get(globallock); if(globallock->status!=GET_LOCK_GOT) { logp("Could not get lock %s (%d)\n", lockpath, globallock->status); free_w(&lockpath); return 1; } logp("Got %s\n", lockpath); } ret=iterate_over_clients(globalcs, grouplist, ext, maxlinks); confs_free(&globalcs); lock_release(globallock); lock_free(&globallock); strlists_free(&grouplist); } if(!nonburp) { logp("%d client storages scanned\n", ccount); } logp("%llu duplicate %s found\n", count, count==1?"file":"files"); logp("%llu bytes %s%s\n", savedbytes, (makelinks || deletedups)?"saved":"saveable", bytes_to_human(savedbytes)); return ret; }
int main(int argc, char *argv[]) { int i=1; int ret=0; int option=0; int nonburp=0; unsigned int maxlinks=DEF_MAX_LINKS; char *groups=NULL; char ext[16]=""; int givenconfigfile=0; prog=basename(argv[0]); init_log(prog); const char *configfile=NULL; configfile=get_config_path(); snprintf(ext, sizeof(ext), ".bedup.%d", getpid()); while((option=getopt(argc, argv, "c:g:hlmnv?"))!=-1) { switch(option) { case 'c': configfile=optarg; givenconfigfile=1; break; case 'g': groups=optarg; break; case 'l': makelinks=1; break; case 'm': maxlinks=atoi(optarg); break; case 'n': nonburp=1; break; case 'v': printf("%s-%s\n", prog, VERSION); return 0; case 'h': case '?': return usage(); } } if(nonburp && givenconfigfile) { logp("-n and -c options are mutually exclusive\n"); return 1; } if(nonburp && groups) { logp("-n and -g options are mutually exclusive\n"); return 1; } if(!nonburp && maxlinks!=DEF_MAX_LINKS) { logp("-m option is specified via the configuration file in burp mode (max_hardlinks=)\n"); return 1; } if(optind>=argc) { if(nonburp) { logp("No directories found after options\n"); return 1; } } else { if(!nonburp) { logp("Do not specify extra arguments.\n"); return 1; } } if(maxlinks<2) { logp("The argument to -m needs to be greater than 1.\n"); return 1; } if(nonburp) { // Read directories from command line. for(i=optind; i<argc; i++) { // Strip trailing slashes, for tidiness. if(argv[i][strlen(argv[i])-1]=='/') argv[i][strlen(argv[i])-1]='\0'; if(process_dir("", argv[i], ext, maxlinks, 0 /* not burp mode */, 0 /* level */)) { ret=1; break; } } } else { int gcount=0; struct config conf; char *globallock=NULL; struct strlist **grouplist=NULL; if(groups) { char *tok=NULL; if((tok=strtok(groups, ",\n"))) { do { if(strlist_add(&grouplist, &gcount, tok, 1)) { logp("out of memory\n"); return -1; } } while((tok=strtok(NULL, ",\n"))); } if(!gcount) { logp("unable to read list of groups\n"); return -1; } } // Read directories from config files, and get locks. init_config(&conf); if(load_config(configfile, &conf, 1)) return 1; if(conf.mode!=MODE_SERVER) { logp("%s is not a server config file\n", configfile); free_config(&conf); return 1; } logp("Dedup clients from %s\n", conf.clientconfdir); maxlinks=conf.max_hardlinks; if(gcount) { logp("in dedup groups:\n"); for(i=0; i<gcount; i++) logp("%s\n", grouplist[i]->path); } else { // Only get the global lock when doing a global run. // If you are doing individual groups, you are likely // to want to do many different dedup jobs and a // global lock would get in the way. if(!(globallock=prepend(conf.lockfile, ".bedup", ""))) return 1; if(get_lock(globallock)) { logp("Could not get %s\n", globallock); return 1; } logp("Got %s\n", globallock); } ret=iterate_over_clients(&conf, grouplist, gcount, ext, maxlinks); free_config(&conf); if(globallock) { unlink(globallock); free(globallock); } } if(!nonburp) { logp("%d client storages scanned\n", ccount); } logp("%llu duplicate %s found\n", count, count==1?"file":"files"); logp("%llu bytes %s%s\n", savedbytes, makelinks?"saved":"saveable", bytes_to_human(savedbytes)); return ret; }
const char *bytes_to_human_str(const char *str) { return bytes_to_human(strtoull(str, NULL, 10)); }