1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/* du.c - disk usage program.
*
* Copyright 2012 Ashwini Kumar <ak.ashwini@gmail.com>
*
* See http://opengroup.org/onlinepubs/9699919799/utilities/du.html
*
* TODO: cleanup
USE_DU(NEWTOY(du, "d#<0=-1hmlcaHkKLsx[-HL][-kKmh]", TOYFLAG_USR|TOYFLAG_BIN))
config DU
bool "du"
default y
help
usage: du [-d N] [-askxHLlmc] [file...]
Show disk usage, space consumed by files and directories.
Size in:
-k 1024 byte blocks (default)
-K 512 byte blocks (posix)
-m Megabytes
-h Human readable (e.g., 1K 243M 2G)
What to show:
-a All files, not just directories
-H Follow symlinks on cmdline
-L Follow all symlinks
-s Only total size of each argument
-x Don't leave this filesystem
-c Cumulative total
-d N Only depth < N
-l Disable hardlink filter
*/
#define FOR_du
#include "toys.h"
GLOBALS(
long d;
unsigned long depth, total;
dev_t st_dev;
void *inodes;
)
typedef struct node_size {
struct dirtree *node;
long size;
} node_size;
// Print the size and name, given size in bytes
static void print(long long size, struct dirtree *node)
{
char *name = "total";
if (TT.depth > TT.d) return;
if (toys.optflags & FLAG_h) {
human_readable(toybuf, size, 0);
printf("%s", toybuf);
} else {
int bits = 10;
if (toys.optflags & FLAG_K) bits = 9;
else if (toys.optflags & FLAG_m) bits = 20;
printf("%llu", (size>>bits)+!!(size&((1<<bits)-1)));
}
if (node) name = dirtree_path(node, NULL);
xprintf("\t%s\n", name);
if (node) free(name);
}
// Return whether or not we've seen this inode+dev, adding it to the list if
// we haven't.
static int seen_inode(void **list, struct stat *st)
{
if (!st) llist_traverse(st, free);
// Skipping dir nodes isn't _quite_ right. They're not hardlinked, but could
// be bind mounted. Still, it's more efficient and the archivers can't use
// hardlinked directory info anyway. (Note that we don't catch bind mounted
// _files_ because it doesn't change st_nlink.)
else if (!S_ISDIR(st->st_mode) && st->st_nlink > 1) {
struct inode_list {
struct inode_list *next;
ino_t ino;
dev_t dev;
} *new;
for (new = *list; new; new = new->next)
if(new->ino == st->st_ino && new->dev == st->st_dev)
return 1;
new = xzalloc(sizeof(*new));
new->ino = st->st_ino;
new->dev = st->st_dev;
new->next = *list;
*list = new;
}
return 0;
}
// dirtree callback, compute/display size of node
static int do_du(struct dirtree *node)
{
unsigned long blocks;
if (!node->parent) TT.st_dev = node->st.st_dev;
else if (!dirtree_notdotdot(node)) return 0;
// detect swiching filesystems
if ((toys.optflags & FLAG_x) && (TT.st_dev != node->st.st_dev))
return 0;
// Don't loop endlessly on recursive directory symlink
if (toys.optflags & FLAG_L) {
struct dirtree *try = node;
while ((try = try->parent))
if (node->st.st_dev==try->st.st_dev && node->st.st_ino==try->st.st_ino)
return 0;
}
// Don't count hard links twice
if (!(toys.optflags & FLAG_l) && !node->again)
if (seen_inode(&TT.inodes, &node->st)) return 0;
// Collect child info before printing directory size
if (S_ISDIR(node->st.st_mode)) {
if (!node->again) {
TT.depth++;
return DIRTREE_COMEAGAIN|(DIRTREE_SYMFOLLOW*!!(toys.optflags&FLAG_L));
} else TT.depth--;
}
// Modern compilers' optimizers are insane and think signed overflow
// behaves differently than unsigned overflow. Sigh. Big hammer.
blocks = node->st.st_blocks + (unsigned long)node->extra;
node->extra = blocks;
if (node->parent)
node->parent->extra = (unsigned long)node->parent->extra+blocks;
else TT.total += node->extra;
if ((toys.optflags & FLAG_a) || !node->parent
|| (S_ISDIR(node->st.st_mode) && !(toys.optflags & FLAG_s)))
{
blocks = node->extra;
print(blocks*512LL, node);
}
return 0;
}
void du_main(void)
{
char *noargs[] = {".", 0}, **args;
// Loop over command line arguments, recursing through children
for (args = toys.optc ? toys.optargs : noargs; *args; args++)
dirtree_flagread(*args, DIRTREE_SYMFOLLOW*!!(toys.optflags&(FLAG_H|FLAG_L)),
do_du);
if (toys.optflags & FLAG_c) print(TT.total*512, 0);
if (CFG_TOYBOX_FREE) seen_inode(TT.inodes, 0);
}
|
