mirror of
https://github.com/git/git
synced 2024-08-24 18:26:02 +00:00
![Jeff King](/assets/img/avatar_default.png)
We frequently allocate strings as xmalloc(len + 1), where the extra 1 is for the NUL terminator. This can be done more simply with xmallocz, which also checks for integer overflow. There's no case where switching xmalloc(n+1) to xmallocz(n) is wrong; the result is the same length, and malloc made no guarantees about what was in the buffer anyway. But in some cases, we can stop manually placing NUL at the end of the allocated buffer. But that's only safe if it's clear that the contents will always fill the buffer. In each case where this patch does so, I manually examined the control flow, and I tried to err on the side of caution. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
268 lines
6.3 KiB
C
268 lines
6.3 KiB
C
/*
|
|
* Simple text-based progress display module for GIT
|
|
*
|
|
* Copyright (c) 2007 by Nicolas Pitre <nico@fluxnic.net>
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include "git-compat-util.h"
|
|
#include "gettext.h"
|
|
#include "progress.h"
|
|
#include "strbuf.h"
|
|
#include "trace.h"
|
|
|
|
#define TP_IDX_MAX 8
|
|
|
|
struct throughput {
|
|
off_t curr_total;
|
|
off_t prev_total;
|
|
uint64_t prev_ns;
|
|
unsigned int avg_bytes;
|
|
unsigned int avg_misecs;
|
|
unsigned int last_bytes[TP_IDX_MAX];
|
|
unsigned int last_misecs[TP_IDX_MAX];
|
|
unsigned int idx;
|
|
struct strbuf display;
|
|
};
|
|
|
|
struct progress {
|
|
const char *title;
|
|
int last_value;
|
|
unsigned total;
|
|
unsigned last_percent;
|
|
unsigned delay;
|
|
unsigned delayed_percent_treshold;
|
|
struct throughput *throughput;
|
|
};
|
|
|
|
static volatile sig_atomic_t progress_update;
|
|
|
|
static void progress_interval(int signum)
|
|
{
|
|
progress_update = 1;
|
|
}
|
|
|
|
static void set_progress_signal(void)
|
|
{
|
|
struct sigaction sa;
|
|
struct itimerval v;
|
|
|
|
progress_update = 0;
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
sa.sa_handler = progress_interval;
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_flags = SA_RESTART;
|
|
sigaction(SIGALRM, &sa, NULL);
|
|
|
|
v.it_interval.tv_sec = 1;
|
|
v.it_interval.tv_usec = 0;
|
|
v.it_value = v.it_interval;
|
|
setitimer(ITIMER_REAL, &v, NULL);
|
|
}
|
|
|
|
static void clear_progress_signal(void)
|
|
{
|
|
struct itimerval v = {{0,},};
|
|
setitimer(ITIMER_REAL, &v, NULL);
|
|
signal(SIGALRM, SIG_IGN);
|
|
progress_update = 0;
|
|
}
|
|
|
|
static int is_foreground_fd(int fd)
|
|
{
|
|
int tpgrp = tcgetpgrp(fd);
|
|
return tpgrp < 0 || tpgrp == getpgid(0);
|
|
}
|
|
|
|
static int display(struct progress *progress, unsigned n, const char *done)
|
|
{
|
|
const char *eol, *tp;
|
|
|
|
if (progress->delay) {
|
|
if (!progress_update || --progress->delay)
|
|
return 0;
|
|
if (progress->total) {
|
|
unsigned percent = n * 100 / progress->total;
|
|
if (percent > progress->delayed_percent_treshold) {
|
|
/* inhibit this progress report entirely */
|
|
clear_progress_signal();
|
|
progress->delay = -1;
|
|
progress->total = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
progress->last_value = n;
|
|
tp = (progress->throughput) ? progress->throughput->display.buf : "";
|
|
eol = done ? done : " \r";
|
|
if (progress->total) {
|
|
unsigned percent = n * 100 / progress->total;
|
|
if (percent != progress->last_percent || progress_update) {
|
|
progress->last_percent = percent;
|
|
if (is_foreground_fd(fileno(stderr)) || done) {
|
|
fprintf(stderr, "%s: %3u%% (%u/%u)%s%s",
|
|
progress->title, percent, n,
|
|
progress->total, tp, eol);
|
|
fflush(stderr);
|
|
}
|
|
progress_update = 0;
|
|
return 1;
|
|
}
|
|
} else if (progress_update) {
|
|
if (is_foreground_fd(fileno(stderr)) || done) {
|
|
fprintf(stderr, "%s: %u%s%s",
|
|
progress->title, n, tp, eol);
|
|
fflush(stderr);
|
|
}
|
|
progress_update = 0;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void throughput_string(struct strbuf *buf, off_t total,
|
|
unsigned int rate)
|
|
{
|
|
strbuf_reset(buf);
|
|
strbuf_addstr(buf, ", ");
|
|
strbuf_humanise_bytes(buf, total);
|
|
strbuf_addstr(buf, " | ");
|
|
strbuf_humanise_bytes(buf, rate * 1024);
|
|
strbuf_addstr(buf, "/s");
|
|
}
|
|
|
|
void display_throughput(struct progress *progress, off_t total)
|
|
{
|
|
struct throughput *tp;
|
|
uint64_t now_ns;
|
|
unsigned int misecs, count, rate;
|
|
|
|
if (!progress)
|
|
return;
|
|
tp = progress->throughput;
|
|
|
|
now_ns = getnanotime();
|
|
|
|
if (!tp) {
|
|
progress->throughput = tp = calloc(1, sizeof(*tp));
|
|
if (tp) {
|
|
tp->prev_total = tp->curr_total = total;
|
|
tp->prev_ns = now_ns;
|
|
strbuf_init(&tp->display, 0);
|
|
}
|
|
return;
|
|
}
|
|
tp->curr_total = total;
|
|
|
|
/* only update throughput every 0.5 s */
|
|
if (now_ns - tp->prev_ns <= 500000000)
|
|
return;
|
|
|
|
/*
|
|
* We have x = bytes and y = nanosecs. We want z = KiB/s:
|
|
*
|
|
* z = (x / 1024) / (y / 1000000000)
|
|
* z = x / y * 1000000000 / 1024
|
|
* z = x / (y * 1024 / 1000000000)
|
|
* z = x / y'
|
|
*
|
|
* To simplify things we'll keep track of misecs, or 1024th of a sec
|
|
* obtained with:
|
|
*
|
|
* y' = y * 1024 / 1000000000
|
|
* y' = y * (2^10 / 2^42) * (2^42 / 1000000000)
|
|
* y' = y / 2^32 * 4398
|
|
* y' = (y * 4398) >> 32
|
|
*/
|
|
misecs = ((now_ns - tp->prev_ns) * 4398) >> 32;
|
|
|
|
count = total - tp->prev_total;
|
|
tp->prev_total = total;
|
|
tp->prev_ns = now_ns;
|
|
tp->avg_bytes += count;
|
|
tp->avg_misecs += misecs;
|
|
rate = tp->avg_bytes / tp->avg_misecs;
|
|
tp->avg_bytes -= tp->last_bytes[tp->idx];
|
|
tp->avg_misecs -= tp->last_misecs[tp->idx];
|
|
tp->last_bytes[tp->idx] = count;
|
|
tp->last_misecs[tp->idx] = misecs;
|
|
tp->idx = (tp->idx + 1) % TP_IDX_MAX;
|
|
|
|
throughput_string(&tp->display, total, rate);
|
|
if (progress->last_value != -1 && progress_update)
|
|
display(progress, progress->last_value, NULL);
|
|
}
|
|
|
|
int display_progress(struct progress *progress, unsigned n)
|
|
{
|
|
return progress ? display(progress, n, NULL) : 0;
|
|
}
|
|
|
|
struct progress *start_progress_delay(const char *title, unsigned total,
|
|
unsigned percent_treshold, unsigned delay)
|
|
{
|
|
struct progress *progress = malloc(sizeof(*progress));
|
|
if (!progress) {
|
|
/* unlikely, but here's a good fallback */
|
|
fprintf(stderr, "%s...\n", title);
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
progress->title = title;
|
|
progress->total = total;
|
|
progress->last_value = -1;
|
|
progress->last_percent = -1;
|
|
progress->delayed_percent_treshold = percent_treshold;
|
|
progress->delay = delay;
|
|
progress->throughput = NULL;
|
|
set_progress_signal();
|
|
return progress;
|
|
}
|
|
|
|
struct progress *start_progress(const char *title, unsigned total)
|
|
{
|
|
return start_progress_delay(title, total, 0, 0);
|
|
}
|
|
|
|
void stop_progress(struct progress **p_progress)
|
|
{
|
|
stop_progress_msg(p_progress, _("done"));
|
|
}
|
|
|
|
void stop_progress_msg(struct progress **p_progress, const char *msg)
|
|
{
|
|
struct progress *progress = *p_progress;
|
|
if (!progress)
|
|
return;
|
|
*p_progress = NULL;
|
|
if (progress->last_value != -1) {
|
|
/* Force the last update */
|
|
char buf[128], *bufp;
|
|
size_t len = strlen(msg) + 5;
|
|
struct throughput *tp = progress->throughput;
|
|
|
|
bufp = (len < sizeof(buf)) ? buf : xmallocz(len);
|
|
if (tp) {
|
|
unsigned int rate = !tp->avg_misecs ? 0 :
|
|
tp->avg_bytes / tp->avg_misecs;
|
|
throughput_string(&tp->display, tp->curr_total, rate);
|
|
}
|
|
progress_update = 1;
|
|
xsnprintf(bufp, len + 1, ", %s.\n", msg);
|
|
display(progress, progress->last_value, bufp);
|
|
if (buf != bufp)
|
|
free(bufp);
|
|
}
|
|
clear_progress_signal();
|
|
if (progress->throughput)
|
|
strbuf_release(&progress->throughput->display);
|
|
free(progress->throughput);
|
|
free(progress);
|
|
}
|