kotovalexarian-likes-gitlab/sortix--sortix
1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
Code Releases Activity
sortix--sortix/utils/du.cpp
Jonas 'Sortie' Termansen 10daa40f01 Fix du(1) argument parsing.
2014-03-01 14:37:39 +01:00

487 lines
16 KiB
C++
Raw Blame History

/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2013.
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.
du.cpp
Estimate file space usage.
*******************************************************************************/
// TODO: Currently hardlinks count twice!
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <error.h>
#include <dirent.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if !defined(VERSIONSTR)
#define VERSIONSTR "unknown version"
#endif
const int FLAG_ALL = 1 << 0;
const int FLAG_SUMMARIZE = 1 << 1;
const int FLAG_SAME_DEVICE = 1 << 2;
const int FLAG_APPARENT_SIZE = 1 << 3;
const int FLAG_TOTAL = 1 << 4;
const int FLAG_HUMAN_READABLE = 1 << 5;
const int FLAG_SI = 1 << 6;
const int FLAG_SEPARATE_DIRS = 1 << 7;
const int FLAG_IS_OPERAND = 1 << 8;
enum symbolic_dereference
{
SYMBOLIC_DEREFERENCE_NONE,
SYMBOLIC_DEREFERENCE_ARGUMENTS,
SYMBOLIC_DEREFERENCE_ALWAYS,
};
static bool string_has_prefix(const char* string, const char* prefix)
{
return !strncmp(string, prefix, strlen(prefix));
}
static char* append_to_path(const char* path, const char* elem)
{
size_t path_length = strlen(path);
if ( !path_length )
return errno = EINVAL, (char*) NULL;
size_t elem_length = strlen(elem);
size_t result_length = path_length + elem_length;
const char* extra_slash = "";
if ( path[path_length-1] != '/' )
{
result_length += 1;
extra_slash = "/";
}
char* result = (char*) malloc(sizeof(char) * (result_length+1));
if ( !result )
return NULL;
stpcpy(stpcpy(stpcpy(result, path), extra_slash), elem);
return result;
}
static uintmax_t size_to_blocks(off_t size, uintmax_t block_size)
{
uintmax_t umax_size = (uintmax_t) size;
return umax_size / block_size + (umax_size % block_size ? 1 : 0);
}
static uintmax_t parse_block_size(const char* block_size_str)
{
if ( !block_size_str[0] )
return 0;
const char* endptr;
uintmax_t ret = strtoumax((char*) block_size_str, (char**) &endptr, 0);
if ( !ret && block_size_str[0] == '0' )
return 0;
if ( endptr[0] && endptr[1] && (endptr[1] != 'B' || endptr[2]) )
return 0;
uintmax_t magnitude = 1;
uintmax_t exponent = endptr[0] && endptr[1] == 'B' ? 1000 : 1024;
char prefixes[] = { '\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' };
size_t num_prefixes = sizeof(prefixes) / sizeof(prefixes[0]);
size_t prefix_index;
for ( prefix_index = 0;
*endptr != prefixes[prefix_index] && prefix_index < num_prefixes;
prefix_index++ )
magnitude *= exponent;
if ( prefix_index == num_prefixes )
return 0;
if ( !ret )
ret = 1;
return ret * magnitude;
}
static void print_disk_usage(uintmax_t num_bytes, uintmax_t block_size,
int flags, const char* path)
{
if ( flags & FLAG_HUMAN_READABLE )
{
uintmax_t value = num_bytes;
uintmax_t exponent = flags & FLAG_SI ? 1000 : 1024;
char prefixes[] = { '\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' };
size_t num_prefixes = sizeof(prefixes) / sizeof(prefixes[0]);
size_t prefix_index = 0;
while ( exponent <= value && prefix_index + 1 < num_prefixes)
{
value /= exponent;
prefix_index++;
}
char prefix_str[2] = { prefixes[prefix_index], '\0' };
printf("%ju%s\t%s\n", value, prefix_str, path);
}
else
{
uintmax_t num_blocks = size_to_blocks(num_bytes, block_size);
printf("%ju\t%s\n", num_blocks, path);
}
}
static
bool disk_usage_file_at(int relfd,
const char* relpath,
const char* path,
int flags,
enum symbolic_dereference symbolic_dereference,
uintmax_t block_size,
uintmax_t* total_bytes_ptr,
uintmax_t* num_bytes_ptr,
dev_t expected_dev = 0,
mode_t* result_mode_ptr = NULL)
{
bool flag_all = flags & FLAG_ALL;
bool flag_is_operand = flags & FLAG_IS_OPERAND;
bool flag_same_device = flags & FLAG_SAME_DEVICE;
bool flag_separate_dirs = flags & FLAG_SEPARATE_DIRS;
bool flag_summarize = flags & FLAG_SUMMARIZE;
bool print_if_file = flag_is_operand || (!flag_summarize && flag_all);
bool print_if_dir = (flags & FLAG_IS_OPERAND) || !(flags & FLAG_SUMMARIZE);
bool follow_symlinks =
symbolic_dereference == SYMBOLIC_DEREFERENCE_ALWAYS ||
(flag_is_operand && symbolic_dereference == SYMBOLIC_DEREFERENCE_ARGUMENTS);
int open_flags = O_RDONLY | (!follow_symlinks ? O_NOFOLLOW : 0);
int fd = openat(relfd, relpath, open_flags);
if ( fd < 0 )
{
if ( errno == ELOOP && !follow_symlinks )
{
if ( print_if_file )
print_disk_usage(0, block_size, flags, path);
if ( num_bytes_ptr )
*num_bytes_ptr = 0;
if ( result_mode_ptr )
*result_mode_ptr = S_IFLNK;
return true;
}
return error(0, errno, "cannot access `%s'", path), false;
}
struct stat st;
if ( fstat(fd, &st) != 0 )
{
error(0, errno, "stat: `%s'", path);
close(fd);
return false;
}
if ( result_mode_ptr )
*result_mode_ptr = st.st_mode;
if ( flag_is_operand )
expected_dev = st.st_dev;
else if ( flag_same_device && st.st_dev != expected_dev )
return true;
uintmax_t num_bytes = flags & FLAG_APPARENT_SIZE ?
(uintmax_t) st.st_size :
st.st_blocks * 512;
if ( !S_ISDIR(st.st_mode) )
{
if ( print_if_file )
print_disk_usage(num_bytes, block_size, flags, path);
if ( num_bytes_ptr )
*num_bytes_ptr = num_bytes;
if ( total_bytes_ptr )
*total_bytes_ptr += num_bytes;
close(fd);
return true;
}
if ( total_bytes_ptr )
*total_bytes_ptr += num_bytes;
DIR* dir = fdopendir(fd);
if ( !dir )
{
error(0, errno, "fdopendir(%i): `%s'", fd, path);
close(fd);
return false;
}
bool success = true;
while ( struct dirent* entry = readdir(dir) )
{
if ( !strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..") )
continue;
char* new_path = append_to_path(path, entry->d_name);
if ( !new_path )
{
error(0, errno, "malloc: `%s/%s'", path, entry->d_name);
continue;
}
int new_flags = flags & ~FLAG_IS_OPERAND;
uintmax_t new_num_bytes = 0;
mode_t new_mode = 0;
if ( !disk_usage_file_at(dirfd(dir), entry->d_name, new_path, new_flags,
symbolic_dereference, block_size,
total_bytes_ptr, &new_num_bytes, expected_dev,
&new_mode) )
success = false;
if ( !flag_separate_dirs || !S_ISDIR(new_mode) )
num_bytes += new_num_bytes;
free(new_path);
}
if ( num_bytes_ptr )
*num_bytes_ptr = num_bytes;
#if defined(__sortix__)
if ( derror(dir) )
{
error(0, errno, "reading directory `%s'", path);
closedir(dir);
return false;
}
#endif
if ( print_if_dir )
print_disk_usage(num_bytes, block_size, flags, path);
closedir(dir);
return success;
}
static void usage(FILE* fp, const char* argv0)
{
fprintf(fp, "Usage: %s [OPTION]... [FILE]...\n", argv0);
fprintf(fp, "Summarize disk usage of each FILE, recursively for directories.\n");
fprintf(fp, "\n");
fprintf(fp, "Mandatory arguments to long options are mandatory for short options too.\n");
fprintf(fp, " -a, --all write counts for all files, not just directories\n");
fprintf(fp, " --apparent-size print apparent sizes, rather than disk usage; although\n");
fprintf(fp, " the apparent size is usually smaller, it may be\n");
fprintf(fp, " larger due to holes in (`sparse') files, internal\n");
fprintf(fp, " fragmentation, indirect blocks, and the like\n");
fprintf(fp, " -B, --block-size=SIZE scale sizes by SIZE before printing them. E.g.,\n");
fprintf(fp, " `-BM' prints sizes in units of 1,048,576 bytes.\n");
fprintf(fp, " See SIZE format below.\n");
fprintf(fp, " -b, --bytes equivalent to `--apparent-size --block-size=1'\n");
fprintf(fp, " -c, --total produce a grand total\n");
fprintf(fp, " -D, --dereference-args dereference only symlinks that are listed on the\n");
fprintf(fp, " command line\n");
fprintf(fp, " -H equivalent to --dereference-args (-D)\n");
fprintf(fp, " -h, --human-readable print sizes in human readable format (e.g., 1K 234M 2G)\n");
fprintf(fp, " --si like -h, but use powers of 1000 not 1024\n");
fprintf(fp, " -k like --block-size=1K\n");
fprintf(fp, " -m like --block-size=1M\n");
fprintf(fp, " -L, --dereference dereference all symbolic links\n");
fprintf(fp, " -P, --no-dereference don't follow any symbolic links (this is the default)\n");
fprintf(fp, " -S, --separate-dirs do not include size of subdirectories\n");
fprintf(fp, " -s, --summarize display only a total for each argument\n");
fprintf(fp, " -x, --one-file-system skip directories on different file systems\n");
fprintf(fp, " --help display this help and exit\n");
fprintf(fp, " --usage display this help and exit\n");
fprintf(fp, " --version output version information and exit\n");
fprintf(fp, "\n");
fprintf(fp, "Display values are in units of the first available SIZE from --block-size,\n");
fprintf(fp, "and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.\n");
fprintf(fp, "Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).\n");
fprintf(fp, "\n");
fprintf(fp, "SIZE may be (or may be an integer optionally followed by) one of following:\n");
fprintf(fp, "KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n");
}
static void help(FILE* fp, const char* argv0)
{
usage(fp, argv0);
}
static void version(FILE* fp, const char* argv0)
{
fprintf(fp, "%s (Sortix) %s\n", argv0, VERSIONSTR);
fprintf(fp, "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.\n");
fprintf(fp, "This is free software: you are free to change and redistribute it.\n");
fprintf(fp, "There is NO WARRANTY, to the extent permitted by law.\n");
}
static void compact_arguments(int* argc, char*** argv)
{
for ( int i = 0; i < *argc; i++ )
while ( i < *argc && !(*argv)[i] )
{
for ( int n = i; n < *argc; n++ )
(*argv)[n] = (*argv)[n+1];
(*argc)--;
}
}
static
bool disk_usage_files(int argc,
char* argv[],
int flags,
enum symbolic_dereference symbolic_dereference,
uintmax_t block_size)
{
bool success = true;
uintmax_t total_bytes = 0;
if ( argc <= 1 )
{
if ( !disk_usage_file_at(AT_FDCWD, ".", ".", flags | FLAG_IS_OPERAND,
symbolic_dereference, block_size, &total_bytes,
NULL) )
success = false;
}
else for ( int i = 1; i < argc; i++ )
{
const char* path = argv[i];
if ( !disk_usage_file_at(AT_FDCWD, path, path, flags | FLAG_IS_OPERAND,
symbolic_dereference, block_size, &total_bytes,
NULL) )
success = false;
}
if ( flags & FLAG_TOTAL )
print_disk_usage(total_bytes, block_size, flags, "total");
return success;
}
static uintmax_t get_default_block_size()
{
uintmax_t result = 0;
if ( !result && getenv("DU_BLOCK_SIZE") )
result = parse_block_size(getenv("DU_BLOCK_SIZE"));
if ( !result && getenv("BLOCK_SIZE") )
result = parse_block_size(getenv("BLOCK_SIZE"));
if ( !result && getenv("BLOCKSIZE") )
result = parse_block_size(getenv("BLOCKSIZE"));
if ( !result && getenv("POSIXLY_CORRECT") )
result = 512;
if ( !result )
result = 1024;
return result;
}
int main(int argc, char* argv[])
{
int flags = 0;
enum symbolic_dereference symbolic_dereference = SYMBOLIC_DEREFERENCE_NONE;
uintmax_t block_size = get_default_block_size();
const char* argv0 = argv[0];
for ( int i = 1; i < argc; i++ )
{
const char* arg = argv[i];
if ( arg[0] != '-' || !arg[1] )
continue;
argv[i] = NULL;
if ( !strcmp(arg, "--") )
break;
if ( arg[1] != '-' )
{
while ( char c = *++arg ) switch ( c )
{
case 'a': flags |= FLAG_ALL; break;
case 'b': flags |= FLAG_APPARENT_SIZE, block_size = 1; break;
case 'B':
if ( !arg[1] )
goto next_is_block_size_operand;
if ( !(block_size = parse_block_size(arg+1)) )
error(1, 0, "invalid block size `%s'", arg);
arg += strlen(arg)-1;
break;
case 'c': flags |= FLAG_TOTAL; break;
case 'D': symbolic_dereference = SYMBOLIC_DEREFERENCE_ARGUMENTS; break;
case 'h': flags |= FLAG_HUMAN_READABLE; break;
case 'H': symbolic_dereference = SYMBOLIC_DEREFERENCE_ARGUMENTS; break;
case 'k': block_size = 1024; break;
case 'L': symbolic_dereference = SYMBOLIC_DEREFERENCE_ALWAYS; break;
case 'm': block_size = 1024*1024; break;
case 'P': symbolic_dereference = SYMBOLIC_DEREFERENCE_NONE; break;
case 's': flags |= FLAG_SUMMARIZE; break;
case 'S': flags |= FLAG_SEPARATE_DIRS; break;
case 'x': flags |= FLAG_SAME_DEVICE; break;
default:
fprintf(stderr, "%s: unknown option -- '%c'\n", argv0, c);
usage(stderr, argv0);
exit(1);
}
}
else if ( !strcmp(arg, "--help") )
help(stdout, argv0), exit(0);
else if ( !strcmp(arg, "--usage") )
usage(stdout, argv0), exit(0);
else if ( !strcmp(arg, "--version") )
version(stdout, argv0), exit(0);
else if ( !strcmp(arg, "--all") )
flags |= FLAG_ALL;
else if ( !strcmp(arg, "--apparent-size") )
flags |= FLAG_APPARENT_SIZE;
else if ( !strcmp(arg, "--block-size") )
{
next_is_block_size_operand:
if ( i + 1 == argc )
error(1, 0, "expected operand after `%s'", arg);
const char* block_size_str = argv[++i];
argv[i] = NULL;
if ( !(block_size = parse_block_size(block_size_str)) )
error(1, 0, "invalid block size `%s'", block_size_str);
}
else if ( string_has_prefix(arg, "--block-size=") )
{
const char* block_size_str = arg + strlen("--block-size=");
if ( !(block_size = parse_block_size(block_size_str)) )
error(1, 0, "invalid block size `%s'", block_size_str);
}
else if ( !strcmp(arg, "--bytes") )
flags |= FLAG_APPARENT_SIZE, block_size = 1;
else if ( !strcmp(arg, "--dereference") )
symbolic_dereference = SYMBOLIC_DEREFERENCE_ALWAYS;
else if ( !strcmp(arg, "--dereference-args") )
symbolic_dereference = SYMBOLIC_DEREFERENCE_ARGUMENTS;
else if ( !strcmp(arg, "--human-readable") )
flags |= FLAG_HUMAN_READABLE;
else if ( !strcmp(arg, "--no-dereference") )
symbolic_dereference = SYMBOLIC_DEREFERENCE_NONE;
else if ( !strcmp(arg, "--one-file-system") )
flags |= FLAG_SAME_DEVICE;
else if ( !strcmp(arg, "--separate-dirs") )
flags |= FLAG_SEPARATE_DIRS;
else if ( !strcmp(arg, "--si") )
flags |= FLAG_HUMAN_READABLE | FLAG_SI;
else if ( !strcmp(arg, "--summarize") )
flags |= FLAG_SUMMARIZE;
else if ( !strcmp(arg, "--total") )
flags |= FLAG_TOTAL;
else
{
fprintf(stderr, "%s: unknown option: %s\n", argv0, arg);
usage(stderr, argv0);
exit(1);
}
}
compact_arguments(&argc, &argv);
return disk_usage_files(argc, argv, flags, symbolic_dereference,
block_size) ? 0 : 1;
}
View git blame Copy permalink