static void gpt_list_table(int xtra UNUSED_PARAM) { int i; char numstr6[6]; smart_ulltoa5(total_number_of_sectors * sector_size, numstr6, " KMGTPEZY")[0] = '\0'; printf("Disk %s: %llu sectors, %s\n", disk_device, (unsigned long long)total_number_of_sectors, numstr6); printf("Logical sector size: %u\n", sector_size); printf("Disk identifier (GUID): "); gpt_print_guid(gpt_hdr->disk_guid); printf("\nPartition table holds up to %u entries\n", (int)SWAP_LE32(gpt_hdr->n_parts)); printf("First usable sector is %llu, last usable sector is %llu\n\n", (unsigned long long)SWAP_LE64(gpt_hdr->first_usable_lba), (unsigned long long)SWAP_LE64(gpt_hdr->last_usable_lba)); printf("Number Start (sector) End (sector) Size Code Name\n"); for (i = 0; i < n_parts; i++) { gpt_partition *p = gpt_part(i); if (p->lba_start) { smart_ulltoa5((1 + SWAP_LE64(p->lba_end) - SWAP_LE64(p->lba_start)) * sector_size, numstr6, " KMGTPEZY")[0] = '\0'; printf("%4u %15llu %15llu %11s %04x ", i + 1, (unsigned long long)SWAP_LE64(p->lba_start), (unsigned long long)SWAP_LE64(p->lba_end), numstr6, 0x0700 /* FIXME */); gpt_print_wide(p->name, 18); printf("\n"); } } }
/* File already had beg_size bytes. * Then we started downloading. * We downloaded "transferred" bytes so far. * Download is expected to stop when total size (beg_size + transferred) * will be "totalsize" bytes. * If totalsize == 0, then it is unknown. */ void FAST_FUNC bb_progress_update(bb_progress_t *p, uoff_t beg_size, uoff_t transferred, uoff_t totalsize) { char numbuf5[6]; /* 5 + 1 for NUL */ unsigned since_last_update, elapsed; int notty; //transferred = 1234; /* use for stall detection testing */ //totalsize = 0; /* use for unknown size download testing */ elapsed = monotonic_sec(); since_last_update = elapsed - p->last_update_sec; p->last_update_sec = elapsed; if (totalsize != 0 && transferred >= totalsize - beg_size) { /* Last call. Do not skip this update */ transferred = totalsize - beg_size; /* sanitize just in case */ } else if (since_last_update == 0) { /* * Do not update on every call * (we can be called on every network read!) */ return; } /* Before we lose real, unscaled sizes, produce human-readable size string */ smart_ulltoa5(beg_size + transferred, numbuf5, " kMGTPEZY")[0] = '\0'; /* * Scale sizes down if they are close to overflowing. * This allows calculations like (100 * transferred / totalsize) * without risking overflow: we guarantee 10 highest bits to be 0. * Introduced error is less than 1 / 2^12 ~= 0.025% */ while (totalsize >= (1 << 20)) { totalsize >>= 8; beg_size >>= 8; transferred >>= 8; } /* If they were huge, now they are scaled down to [1048575,4096] range. * (N * totalsize) won't overflow 32 bits for N up to 4096. */ #if ULONG_MAX == 0xffffffff /* 32-bit CPU, uoff_t arithmetic is complex on it, cast variables to narrower types */ # define totalsize ((unsigned)totalsize) # define beg_size ((unsigned)beg_size) # define transferred ((unsigned)transferred) #endif notty = !isatty(STDERR_FILENO); if (ENABLE_UNICODE_SUPPORT) fprintf(stderr, "\r%s " + notty, p->curfile); else fprintf(stderr, "\r%-20.20s " + notty, p->curfile); if (totalsize != 0) { int barlength; unsigned beg_and_transferred; /* does not need uoff_t, see scaling code */ unsigned ratio; beg_and_transferred = beg_size + transferred; ratio = 100 * beg_and_transferred / totalsize; /* can't overflow ^^^^^^^^^^^^^^^ */ fprintf(stderr, "%3u%% ", ratio); barlength = get_terminal_width(2) - 48; /* * Must reject barlength <= 0 (terminal too narrow). While at it, * also reject: 1-char bar (useless), 2-char bar (ridiculous). */ if (barlength > 2) { if (barlength > 999) barlength = 999; { /* god bless gcc for variable arrays :) */ char buf[barlength + 1]; unsigned stars = (unsigned)barlength * beg_and_transferred / totalsize; /* can't overflow ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ memset(buf, ' ', barlength); buf[barlength] = '\0'; memset(buf, '*', stars); fprintf(stderr, "|%s| ", buf); } } } fputs(numbuf5, stderr); /* "NNNNk" */ since_last_update = elapsed - p->last_change_sec; if ((unsigned)transferred != p->last_size) { p->last_change_sec = elapsed; p->last_size = (unsigned)transferred; if (since_last_update >= STALLTIME) { /* We "cut out" these seconds from elapsed time * by adjusting start time */ p->start_sec += since_last_update; } since_last_update = 0; /* we are un-stalled now */ } elapsed -= p->start_sec; /* now it's "elapsed since start" */ if (since_last_update >= STALLTIME) { fprintf(stderr, " - stalled -"); } else if (!totalsize || !transferred || (int)elapsed < 0) { fprintf(stderr, " --:--:-- ETA"); } else { unsigned eta, secs, hours; unsigned bytes; bytes = totalsize - beg_size; /* Estimated remaining time = * estimated_sec_to_dl_bytes - elapsed_sec = * bytes / average_bytes_sec_so_far - elapsed = * bytes / (transferred/elapsed) - elapsed = * bytes * elapsed / transferred - elapsed */ eta = (unsigned long)bytes * elapsed / transferred - elapsed; /* if 32bit, can overflow ^^^^^^^^^^, but this would only show bad ETA */ if (eta >= 1000*60*60) eta = 1000*60*60 - 1; #if 0 /* To prevent annoying "back-and-forth" estimation jitter, * if new ETA is larger than the last just by a few seconds, * disregard it, and show last one. The end result is that * ETA usually only decreases, unless download slows down a lot. */ if ((unsigned)(eta - p->last_eta) < 10) eta = p->last_eta; p->last_eta = eta; #endif secs = eta % 3600; hours = eta / 3600; fprintf(stderr, "%3u:%02u:%02u ETA", hours, secs / 60, secs % 60); } if (notty) fputc('\n', stderr); }
static void put_u(char *buf, int size, unsigned u) { char buf5[5]; smart_ulltoa5( ((unsigned long long)u) << 10, buf5); sprintf(buf, "%.*s", size, buf5); }