mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-17 18:02:09 +03:00
(fts_debug, opt_all, apparent_size, opt_count_all,
print_grand_total, opt_separate_dirs, hash_ins, process_file, main): Use bool for booleans. (max_depth): Now size_t, not int, to avoid an arbitrary limit of INT_MAX on depth. (G_fail): Remove: no longer needed, now that the relevant functions return bool. (process_file): Use return value to signal success rather than setting a global. Remove first_call static var; not needed, since we can look at n_alloc. Use size_t for depths. Remove FIXME about size_t casts, as it's now fixed. Use xnrealloc rather than the obsolescent XREALLOC. Don't bother to check whether reallocation is needed unless level > prev_level. (du_files): Invert sense of result, for consistency with other coreutils code. All callers changed. (main): Allow --max-depth values up to SIZE_MAX.
This commit is contained in:
1 parent
c1bbe24045
commit
e4d5fc2283
1 file changed
+101
-111
@@ -43,7 +43,7 @@
|
||||
#include "xfts.h"
|
||||
#include "xstrtol.h"
|
||||
|
||||
extern int fts_debug;
|
||||
extern bool fts_debug;
|
||||
|
||||
/* The official name of this program (e.g., no `g' prefix). */
|
||||
#define PROGRAM_NAME "du"
|
||||
@@ -77,29 +77,29 @@ static Hash_table *htab;
|
||||
/* Name under which this program was invoked. */
|
||||
char *program_name;
|
||||
|
||||
/* If nonzero, display counts for all files, not just directories. */
|
||||
static int opt_all = 0;
|
||||
/* If true, display counts for all files, not just directories. */
|
||||
static bool opt_all = false;
|
||||
|
||||
/* If nonzero, rather than using the disk usage of each file,
|
||||
/* If true, rather than using the disk usage of each file,
|
||||
use the apparent size (a la stat.st_size). */
|
||||
static int apparent_size = 0;
|
||||
static bool apparent_size = false;
|
||||
|
||||
/* If nonzero, count each hard link of files with multiple links. */
|
||||
static int opt_count_all = 0;
|
||||
/* If true, count each hard link of files with multiple links. */
|
||||
static bool opt_count_all = false;
|
||||
|
||||
/* If true, output the NUL byte instead of a newline at the end of each line. */
|
||||
static bool opt_nul_terminate_output = false;
|
||||
|
||||
/* If nonzero, print a grand total at the end. */
|
||||
static int print_grand_total = 0;
|
||||
/* If true, print a grand total at the end. */
|
||||
static bool print_grand_total = false;
|
||||
|
||||
/* If nonzero, do not add sizes of subdirectories. */
|
||||
static int opt_separate_dirs = 0;
|
||||
static bool opt_separate_dirs = false;
|
||||
|
||||
/* Show the total for each directory (and file if --all) that is at
|
||||
most MAX_DEPTH levels down from the root of the hierarchy. The root
|
||||
is at level 0, so `du --max-depth=0' is equivalent to `du -s'. */
|
||||
static int max_depth = INT_MAX;
|
||||
static size_t max_depth = SIZE_MAX;
|
||||
|
||||
/* Human-readable options for output. */
|
||||
static int human_output_opts;
|
||||
@@ -113,9 +113,6 @@ static struct exclude *exclude;
|
||||
/* Grand total size of all args, in bytes. */
|
||||
static uintmax_t tot_size = 0;
|
||||
|
||||
/* Nonzero indicates that du should exit with EXIT_FAILURE upon completion. */
|
||||
static int G_fail;
|
||||
|
||||
#define IS_DIR_TYPE(Type) \
|
||||
((Type) == FTS_DP \
|
||||
|| (Type) == FTS_DNR)
|
||||
@@ -247,10 +244,9 @@ entry_compare (void const *x, void const *y)
|
||||
}
|
||||
|
||||
/* Try to insert the INO/DEV pair into the global table, HTAB.
|
||||
If the pair is successfully inserted, return zero.
|
||||
Upon failed memory allocation exit nonzero.
|
||||
If the pair is already in the table, return nonzero. */
|
||||
static int
|
||||
Return true if the pair is successfully inserted,
|
||||
false if the pair is already in the table. */
|
||||
static bool
|
||||
hash_ins (ino_t ino, dev_t dev)
|
||||
{
|
||||
struct entry *ent;
|
||||
@@ -270,13 +266,13 @@ hash_ins (ino_t ino, dev_t dev)
|
||||
if (ent_from_table == ent)
|
||||
{
|
||||
/* Insertion succeeded. */
|
||||
return 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* That pair is already in the table, so ENT was not inserted. Free it. */
|
||||
free (ent);
|
||||
|
||||
return 1;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Initialize the hash table. */
|
||||
@@ -313,14 +309,15 @@ print_size (uintmax_t n_bytes, const char *string)
|
||||
/* This function is called once for every file system object that fts
|
||||
encounters. fts does a depth-first traversal. This function knows
|
||||
that and accumulates per-directory totals based on changes in
|
||||
the depth of the current entry. */
|
||||
the depth of the current entry. It returns true on success. */
|
||||
|
||||
static void
|
||||
static bool
|
||||
process_file (FTS *fts, FTSENT *ent)
|
||||
{
|
||||
bool ok;
|
||||
uintmax_t size;
|
||||
uintmax_t size_to_print;
|
||||
static int first_call = 1;
|
||||
size_t level;
|
||||
static size_t prev_level;
|
||||
static size_t n_alloc;
|
||||
/* The sum of the st_size values of all entries in the single directory
|
||||
@@ -332,11 +329,11 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
/* The sum of the sizes of all entries in the hierarchy at or below the
|
||||
directory at the specified level. */
|
||||
static uintmax_t *sum_subdir;
|
||||
int print = 1;
|
||||
bool print = true;
|
||||
|
||||
const char *file = ent->fts_path;
|
||||
const struct stat *sb = ent->fts_statp;
|
||||
int skip;
|
||||
bool skip;
|
||||
|
||||
/* If necessary, set FTS_SKIP before returning. */
|
||||
skip = excluded_filename (exclude, ent->fts_name);
|
||||
@@ -347,23 +344,22 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
{
|
||||
case FTS_NS:
|
||||
error (0, ent->fts_errno, _("cannot access %s"), quote (file));
|
||||
G_fail = 1;
|
||||
return;
|
||||
return false;
|
||||
|
||||
case FTS_ERR:
|
||||
/* if (S_ISDIR (ent->fts_statp->st_mode) && FIXME */
|
||||
error (0, ent->fts_errno, _("%s"), quote (file));
|
||||
G_fail = 1;
|
||||
return;
|
||||
return false;
|
||||
|
||||
case FTS_DNR:
|
||||
/* Don't return just yet, since although the directory is not readable,
|
||||
we were able to stat it, so we do have a size. */
|
||||
error (0, ent->fts_errno, _("cannot read directory %s"), quote (file));
|
||||
G_fail = 1;
|
||||
ok = false;
|
||||
break;
|
||||
|
||||
default:
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -371,7 +367,7 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
or if it's the second encounter for a skipped directory, then
|
||||
return right away. */
|
||||
if (ent->fts_info == FTS_D || skip)
|
||||
return;
|
||||
return ok;
|
||||
|
||||
/* If the file is being excluded or if it has already been counted
|
||||
via a hard link, then don't let it contribute to the sums. */
|
||||
@@ -379,13 +375,13 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
|| (!opt_count_all
|
||||
&& ! S_ISDIR (sb->st_mode)
|
||||
&& 1 < sb->st_nlink
|
||||
&& hash_ins (sb->st_ino, sb->st_dev)))
|
||||
&& ! hash_ins (sb->st_ino, sb->st_dev)))
|
||||
{
|
||||
/* Note that we must not simply return here.
|
||||
We still have to update prev_level and maybe propagate
|
||||
some sums up the hierarchy. */
|
||||
size = 0;
|
||||
print = 0;
|
||||
print = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -394,49 +390,44 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
: ST_NBLOCKS (*sb) * ST_NBLOCKSIZE);
|
||||
}
|
||||
|
||||
if (first_call)
|
||||
level = ent->fts_level;
|
||||
size_to_print = size;
|
||||
|
||||
if (n_alloc == 0)
|
||||
{
|
||||
n_alloc = ent->fts_level + 10;
|
||||
sum_ent = XCALLOC (uintmax_t, n_alloc);
|
||||
sum_subdir = XCALLOC (uintmax_t, n_alloc);
|
||||
n_alloc = level + 10;
|
||||
sum_ent = xcalloc (n_alloc, sizeof *sum_ent);
|
||||
sum_subdir = xcalloc (n_alloc, sizeof *sum_subdir);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* FIXME: it's a shame that we need these `size_t' casts to avoid
|
||||
warnings from gcc about `comparison between signed and unsigned'.
|
||||
Probably unavoidable, assuming that the struct members
|
||||
are of type `int' (historical), since I want variables like
|
||||
n_alloc and prev_level to have types that make sense. */
|
||||
if (n_alloc <= (size_t) ent->fts_level)
|
||||
{
|
||||
n_alloc = ent->fts_level * 2;
|
||||
sum_ent = XREALLOC (sum_ent, uintmax_t, n_alloc);
|
||||
sum_subdir = XREALLOC (sum_subdir, uintmax_t, n_alloc);
|
||||
}
|
||||
}
|
||||
|
||||
size_to_print = size;
|
||||
|
||||
if (! first_call)
|
||||
{
|
||||
if ((size_t) ent->fts_level == prev_level)
|
||||
if (level == prev_level)
|
||||
{
|
||||
/* This is usually the most common case. Do nothing. */
|
||||
}
|
||||
else if (ent->fts_level > prev_level)
|
||||
else if (level > prev_level)
|
||||
{
|
||||
/* Descending the hierarchy.
|
||||
Clear the accumulators for *all* levels between prev_level
|
||||
and the current one. The depth may change dramatically,
|
||||
e.g., from 1 to 10. */
|
||||
int i;
|
||||
for (i = prev_level + 1; i <= ent->fts_level; i++)
|
||||
size_t i;
|
||||
|
||||
if (n_alloc <= level)
|
||||
{
|
||||
sum_ent = xnrealloc (sum_ent, level, 2 * sizeof *sum_ent);
|
||||
sum_subdir = xnrealloc (sum_subdir, level,
|
||||
2 * sizeof *sum_subdir);
|
||||
n_alloc = level * 2;
|
||||
}
|
||||
|
||||
for (i = prev_level + 1; i <= level; i++)
|
||||
{
|
||||
sum_ent[i] = 0;
|
||||
sum_subdir[i] = 0;
|
||||
}
|
||||
}
|
||||
else /* ent->fts_level < prev_level */
|
||||
else /* level < prev_level */
|
||||
{
|
||||
/* Ascending the hierarchy.
|
||||
Process a directory only after all entries in that
|
||||
@@ -444,22 +435,20 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
propagate sums from the children (prev_level) to the parent.
|
||||
Here, the current level is always one smaller than the
|
||||
previous one. */
|
||||
assert ((size_t) ent->fts_level == prev_level - 1);
|
||||
assert (level == prev_level - 1);
|
||||
size_to_print += sum_ent[prev_level];
|
||||
if (!opt_separate_dirs)
|
||||
size_to_print += sum_subdir[prev_level];
|
||||
sum_subdir[ent->fts_level] += (sum_ent[prev_level]
|
||||
+ sum_subdir[prev_level]);
|
||||
sum_subdir[level] += sum_ent[prev_level] + sum_subdir[prev_level];
|
||||
}
|
||||
}
|
||||
|
||||
prev_level = ent->fts_level;
|
||||
first_call = 0;
|
||||
prev_level = level;
|
||||
|
||||
/* Let the size of a directory entry contribute to the total for the
|
||||
containing directory, unless --separate-dirs (-S) is specified. */
|
||||
if ( ! (opt_separate_dirs && IS_DIR_TYPE (ent->fts_info)))
|
||||
sum_ent[ent->fts_level] += size;
|
||||
sum_ent[level] += size;
|
||||
|
||||
/* Even if this directory is unreadable or we can't chdir into it,
|
||||
do let its size contribute to the total, ... */
|
||||
@@ -468,16 +457,16 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
/* ... but don't print out a total for it, since without the size(s)
|
||||
of any potential entries, it could be very misleading. */
|
||||
if (ent->fts_info == FTS_DNR)
|
||||
return;
|
||||
return ok;
|
||||
|
||||
/* If we're not counting an entry, e.g., because it's a hard link
|
||||
to a file we've already counted (and --count-links), then don't
|
||||
print a line for it. */
|
||||
if (!print)
|
||||
return;
|
||||
return ok;
|
||||
|
||||
if ((IS_DIR_TYPE (ent->fts_info) && ent->fts_level <= max_depth)
|
||||
|| ((opt_all && ent->fts_level <= max_depth) || ent->fts_level == 0))
|
||||
if ((IS_DIR_TYPE (ent->fts_info) && level <= max_depth)
|
||||
|| ((opt_all && level <= max_depth) || level == 0))
|
||||
{
|
||||
print_only_size (size_to_print);
|
||||
fputc ('\t', stdout);
|
||||
@@ -485,18 +474,19 @@ process_file (FTS *fts, FTSENT *ent)
|
||||
fputc (opt_nul_terminate_output ? '\0' : '\n', stdout);
|
||||
fflush (stdout);
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
/* Recursively print the sizes of the directories (and, if selected, files)
|
||||
named in FILES, the last entry of which is NULL.
|
||||
BIT_FLAGS controls how fts works.
|
||||
If the fts_open call fails, exit nonzero.
|
||||
Otherwise, return nonzero upon error. */
|
||||
Return true if successful. */
|
||||
|
||||
static bool
|
||||
du_files (char **files, int bit_flags)
|
||||
{
|
||||
bool fail = false;
|
||||
bool ok = true;
|
||||
|
||||
if (*files)
|
||||
{
|
||||
@@ -513,13 +503,13 @@ du_files (char **files, int bit_flags)
|
||||
{
|
||||
/* FIXME: try to give a better message */
|
||||
error (0, errno, _("fts_read failed"));
|
||||
fail = true;
|
||||
ok = false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
FTS_CROSS_CHECK (fts);
|
||||
|
||||
process_file (fts, ent);
|
||||
ok &= process_file (fts, ent);
|
||||
}
|
||||
|
||||
/* Ignore failure, since the only way it can do so is in failing to
|
||||
@@ -531,7 +521,7 @@ du_files (char **files, int bit_flags)
|
||||
if (print_grand_total)
|
||||
print_size (tot_size, _("total"));
|
||||
|
||||
return fail;
|
||||
return ok;
|
||||
}
|
||||
|
||||
int
|
||||
@@ -539,17 +529,17 @@ main (int argc, char **argv)
|
||||
{
|
||||
int c;
|
||||
char *cwd_only[2];
|
||||
int max_depth_specified = 0;
|
||||
bool max_depth_specified = false;
|
||||
char **files;
|
||||
bool fail;
|
||||
bool ok = true;
|
||||
char *files_from = NULL;
|
||||
struct Tokens tok;
|
||||
|
||||
/* Bit flags that control how fts works. */
|
||||
int bit_flags = FTS_PHYSICAL | FTS_TIGHT_CYCLE_CHECK;
|
||||
|
||||
/* If nonzero, display only a total for each argument. */
|
||||
int opt_summarize_only = 0;
|
||||
/* If true, display only a total for each argument. */
|
||||
bool opt_summarize_only = false;
|
||||
|
||||
cwd_only[0] = ".";
|
||||
cwd_only[1] = NULL;
|
||||
@@ -567,11 +557,9 @@ main (int argc, char **argv)
|
||||
human_output_opts = human_options (getenv ("DU_BLOCK_SIZE"), false,
|
||||
&output_block_size);
|
||||
|
||||
fail = false;
|
||||
while ((c = getopt_long (argc, argv, DEBUG_OPT "0abchHklmsxB:DLPSX:",
|
||||
long_options, NULL)) != -1)
|
||||
{
|
||||
long int tmp_long;
|
||||
switch (c)
|
||||
{
|
||||
case 0: /* Long option. */
|
||||
@@ -579,7 +567,7 @@ main (int argc, char **argv)
|
||||
|
||||
#if DU_DEBUG
|
||||
case 'd':
|
||||
fts_debug = 1;
|
||||
fts_debug = true;
|
||||
break;
|
||||
#endif
|
||||
|
||||
@@ -588,21 +576,21 @@ main (int argc, char **argv)
|
||||
break;
|
||||
|
||||
case 'a':
|
||||
opt_all = 1;
|
||||
opt_all = true;
|
||||
break;
|
||||
|
||||
case APPARENT_SIZE_OPTION:
|
||||
apparent_size = 1;
|
||||
apparent_size = true;
|
||||
break;
|
||||
|
||||
case 'b':
|
||||
apparent_size = 1;
|
||||
apparent_size = true;
|
||||
human_output_opts = 0;
|
||||
output_block_size = 1;
|
||||
break;
|
||||
|
||||
case 'c':
|
||||
print_grand_total = 1;
|
||||
print_grand_total = true;
|
||||
break;
|
||||
|
||||
case 'h':
|
||||
@@ -625,18 +613,21 @@ main (int argc, char **argv)
|
||||
break;
|
||||
|
||||
case MAX_DEPTH_OPTION: /* --max-depth=N */
|
||||
if (xstrtol (optarg, NULL, 0, &tmp_long, NULL) == LONGINT_OK
|
||||
&& 0 <= tmp_long && tmp_long <= INT_MAX)
|
||||
{
|
||||
max_depth_specified = 1;
|
||||
max_depth = (int) tmp_long;
|
||||
}
|
||||
else
|
||||
{
|
||||
error (0, 0, _("invalid maximum depth %s"),
|
||||
quote (optarg));
|
||||
fail = true;
|
||||
}
|
||||
{
|
||||
unsigned long int tmp_ulong;
|
||||
if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
|
||||
&& tmp_ulong <= SIZE_MAX)
|
||||
{
|
||||
max_depth_specified = true;
|
||||
max_depth = tmp_ulong;
|
||||
}
|
||||
else
|
||||
{
|
||||
error (0, 0, _("invalid maximum depth %s"),
|
||||
quote (optarg));
|
||||
ok = false;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'm': /* obsolescent: FIXME: remove in 2005. */
|
||||
@@ -645,11 +636,11 @@ main (int argc, char **argv)
|
||||
break;
|
||||
|
||||
case 'l':
|
||||
opt_count_all = 1;
|
||||
opt_count_all = true;
|
||||
break;
|
||||
|
||||
case 's':
|
||||
opt_summarize_only = 1;
|
||||
opt_summarize_only = true;
|
||||
break;
|
||||
|
||||
case 'x':
|
||||
@@ -673,7 +664,7 @@ main (int argc, char **argv)
|
||||
break;
|
||||
|
||||
case 'S':
|
||||
opt_separate_dirs = 1;
|
||||
opt_separate_dirs = true;
|
||||
break;
|
||||
|
||||
case 'X':
|
||||
@@ -681,7 +672,7 @@ main (int argc, char **argv)
|
||||
EXCLUDE_WILDCARDS, '\n'))
|
||||
{
|
||||
error (0, errno, "%s", quotearg_colon (optarg));
|
||||
fail = true;
|
||||
ok = false;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -698,14 +689,14 @@ main (int argc, char **argv)
|
||||
case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
|
||||
|
||||
default:
|
||||
fail = true;
|
||||
ok = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (fail)
|
||||
if (!ok)
|
||||
usage (EXIT_FAILURE);
|
||||
|
||||
if (opt_all && opt_summarize_only)
|
||||
if (opt_all & opt_summarize_only)
|
||||
{
|
||||
error (0, 0, _("cannot both summarize and show all entries"));
|
||||
usage (EXIT_FAILURE);
|
||||
@@ -719,9 +710,8 @@ main (int argc, char **argv)
|
||||
|
||||
if (opt_summarize_only && max_depth_specified && max_depth != 0)
|
||||
{
|
||||
error (0, 0,
|
||||
_("warning: summarizing conflicts with --max-depth=%d"),
|
||||
max_depth);
|
||||
unsigned long int d = max_depth;
|
||||
error (0, 0, _("warning: summarizing conflicts with --max-depth=%lu"), d);
|
||||
usage (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@@ -797,10 +787,10 @@ main (int argc, char **argv)
|
||||
}
|
||||
}
|
||||
|
||||
fail = (i != j);
|
||||
ok = (i == j);
|
||||
}
|
||||
|
||||
fail |= du_files (files, bit_flags);
|
||||
ok &= du_files (files, bit_flags);
|
||||
|
||||
/* This isn't really necessary, but it does ensure we
|
||||
exercise this function. */
|
||||
@@ -809,5 +799,5 @@ main (int argc, char **argv)
|
||||
|
||||
hash_free (htab);
|
||||
|
||||
exit (fail || G_fail ? EXIT_FAILURE : EXIT_SUCCESS);
|
||||
exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
Reference in new issue
Block a user