fbt/sbase
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
6b950e436b
sbase/du.c

117 lines
2.1 KiB
C
Raw Normal View History

Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
/* See LICENSE file for copyright and license details. */
Clean up #includes
2015-02-14 20:02:41 +00:00
#include <sys/stat.h>
#include <sys/types.h>
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
#include <errno.h>
#include <limits.h>
include stdint.h for SIZE_MAX
2015-04-29 21:19:36 +00:00
#include <stdint.h>
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
#include <stdlib.h>
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
#include <stdio.h>
du: Use off_t instead of uintmax_t
2015-04-29 11:12:18 +00:00
#include <unistd.h>
Fix coding style It was about damn time. Consistency is very important in such a big codebase.
2014-11-13 17:29:30 +00:00
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before.
2015-03-12 23:25:32 +00:00
#include "fs.h"
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
#include "util.h"
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
static size_t maxdepth = SIZE_MAX;
static size_t blksize = 512;
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
Un-boolify sbase It actually makes the binaries smaller, the code easier to read (gems like "val == true", "val == false" are gone) and actually predictable in the sense of that we actually know what we're working with (one bitwise operator was quite adventurous and should now be fixed). This is also more consistent with the other suckless projects around which don't use boolean types.
2014-11-13 20:24:47 +00:00
static int aflag = 0;
static int sflag = 0;
static int hflag = 0;
Use xrealpath() in du(1)
2014-01-23 21:16:05 +00:00
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
static void
du: Use off_t instead of uintmax_t
2015-04-29 11:12:18 +00:00
printpath(off_t n, const char *path)
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
{
Add human readable output to du(1) Thanks Jeffrey Picard!
2014-10-16 09:06:27 +00:00
if (hflag)
separate humansize into a util function also show 1 decimal of human size string like: 4M -> 4.4M
2014-10-18 21:25:00 +00:00
printf("%s\t%s\n", humansize(n * blksize), path);
Add human readable output to du(1) Thanks Jeffrey Picard!
2014-10-16 09:06:27 +00:00
else
Fix type mismatches Thanks to Random832 for the patch.
2015-11-26 10:24:08 +00:00
printf("%jd\t%s\n", (intmax_t)n, path);
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
}
du: Use off_t instead of uintmax_t
2015-04-29 11:12:18 +00:00
static off_t
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
nblks(blkcnt_t blocks)
Always round up to the next blocksize unit in du(1)
2013-10-18 15:40:31 +00:00
{
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
return (512 * blocks + blksize - 1) / blksize;
Always round up to the next blocksize unit in du(1)
2013-10-18 15:40:31 +00:00
}
du: staticize du
2015-04-24 14:42:48 +00:00
static void
du: Don't print 0 entry if stat of named file fails Previously: $ du doesntexist du: lstat doesntexist: No such file or directory 0 doesntexist Now: $ du doesntexist du: lstat doesntexist: No such file or directory Also, just call nblks one time.
2016-12-15 03:40:03 +00:00
du(const char *path, struct stat *st, void *data, struct recursor *r)
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
{
du: Don't print 0 entry if stat of named file fails Previously: $ du doesntexist du: lstat doesntexist: No such file or directory 0 doesntexist Now: $ du doesntexist du: lstat doesntexist: No such file or directory Also, just call nblks one time.
2016-12-15 03:40:03 +00:00
off_t *total = data, subtotal;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
du: Don't print 0 entry if stat of named file fails Previously: $ du doesntexist du: lstat doesntexist: No such file or directory 0 doesntexist Now: $ du doesntexist du: lstat doesntexist: No such file or directory Also, just call nblks one time.
2016-12-15 03:40:03 +00:00
subtotal = nblks(st->st_blocks);
Remove st != NULL checks from recursor functions In the description of 3111908b034c73673a2f079b2b13a88c18379baa, it says that the functions must be able to handle st being NULL, but recurse always passes a valid pointer. The only function that was ever passed NULL was rm(), but this was changed to go through recurse in 2f4ab527391135e651b256f8654b050ea4a48f3d, so now the checks are pointless.
2016-12-15 03:40:02 +00:00
if (S_ISDIR(st->st_mode))
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before.
2015-03-12 23:25:32 +00:00
recurse(path, &subtotal, r);
du: Don't print 0 entry if stat of named file fails Previously: $ du doesntexist du: lstat doesntexist: No such file or directory 0 doesntexist Now: $ du doesntexist du: lstat doesntexist: No such file or directory Also, just call nblks one time.
2016-12-15 03:40:03 +00:00
*total += subtotal;
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
du: Don't print 0 entry if stat of named file fails Previously: $ du doesntexist du: lstat doesntexist: No such file or directory 0 doesntexist Now: $ du doesntexist du: lstat doesntexist: No such file or directory Also, just call nblks one time.
2016-12-15 03:40:03 +00:00
if (!r->depth)
printpath(*total, path);
else if (!sflag && r->depth <= maxdepth && (S_ISDIR(st->st_mode) || aflag))
printpath(subtotal, path);
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
}
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
static void
usage(void)
{
Add -x support for du(1)
2015-02-18 17:24:21 +00:00
eprintf("usage: %s [-a | -s] [-d depth] [-h] [-k] [-H | -L | -P] [-x] [file ...]\n", argv0);
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}
int
main(int argc, char *argv[])
{
Add maxdepth to recurse() This also makes more sense.
2015-04-18 20:04:49 +00:00
struct recursor r = { .fn = du, .hist = NULL, .depth = 0, .maxdepth = 0,
.follow = 'P', .flags = 0 };
du: Use off_t instead of uintmax_t
2015-04-29 11:12:18 +00:00
off_t n = 0;
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before.
2015-03-12 23:25:32 +00:00
int kflag = 0, dflag = 0;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
char *bsize;
ARGBEGIN {
case 'a':
aflag = 1;
break;
case 'd':
dflag = 1;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
maxdepth = estrtonum(EARGF(usage()), 0, MIN(LLONG_MAX, SIZE_MAX));
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
case 'h':
hflag = 1;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
case 'k':
kflag = 1;
break;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
case 's':
sflag = 1;
break;
case 'x':
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before.
2015-03-12 23:25:32 +00:00
r.flags |= SAMEDEV;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
du.c: add symlink dereferencing flags -H and -L
2015-02-09 22:18:49 +00:00
case 'H':
case 'L':
du: Update usage and document -P as well
2015-02-17 16:07:10 +00:00
case 'P':
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before.
2015-03-12 23:25:32 +00:00
r.follow = ARGC();
Add -x support for du(1)
2015-02-18 17:24:21 +00:00
break;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
default:
usage();
No need for semicolon after ARGEND This is also the style used in Plan 9.
2015-11-01 10:16:49 +00:00
} ARGEND
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
if ((aflag && sflag) || (dflag && sflag))
usage();
bsize = getenv("BLOCKSIZE");
if (bsize)
du: fix possible division by zero if $BLOCKSIZE is 0 these kind of $BLOCKSIZE dont make sense, but dont crash atleast.
2015-03-30 17:58:06 +00:00
blksize = estrtonum(bsize, 1, MIN(LLONG_MAX, SIZE_MAX));
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
if (kflag)
blksize = 1024;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
if (!argc) {
Refactor recurse() again Okay, why yet another recurse()-refactor? The last one added the recursor-struct, which simplified things on the user-end, but there was still one thing that bugged me a lot: Previously, all fn()'s were forced to (l)stat the paths themselves. This does not work well when you try to keep up with H-, L- and P- flags at the same time, as each utility-function would have to set the right function-pointer for (l)stat every single time. This is not desirable. Furthermore, recurse should be easy to use and not involve trouble finding the right (l)stat-function to do it right. So, what we needed was a stat-argument for each fn(), so it is directly accessible. This was impossible to do though when the fn()'s are still directly called by the programs to "start" the recurse. Thus, the fundamental change is to make recurse() the function to go, while designing the fn()'s in a way they can "live" with st being NULL (we don't want a null-pointer-deref). What you can see in this commit is the result of this work. Why all this trouble instead of using nftw? The special thing about recurse() is that you tell the function when to recurse() in your fn(). You don't need special flags to tell nftw() to skip the subtree, just to give an example. The only single downside to this is that now, you are not allowed to unconditionally call recurse() from your fn(). It has to be a directory. However, that is a cost I think is easily weighed up by the advantages. Another thing is the history: I added a procedure at the end of the outmost recurse to free the history. This way we don't leak memory. A simple optimization on the side: - if (h->dev == st.st_dev && h->ino == st.st_ino) + if (h->ino == st.st_ino && h->dev == st.st_dev) First compare the likely difference in inode-numbers instead of checking the unlikely condition that the device-numbers are different.
2015-03-18 23:53:42 +00:00
recurse(".", &n, &r);
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
} else {
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
for (; *argv; argc--, argv++) {
du: Reset size counter for each file read
2015-04-05 21:49:00 +00:00
n = 0;
Refactor recurse() again Okay, why yet another recurse()-refactor? The last one added the recursor-struct, which simplified things on the user-end, but there was still one thing that bugged me a lot: Previously, all fn()'s were forced to (l)stat the paths themselves. This does not work well when you try to keep up with H-, L- and P- flags at the same time, as each utility-function would have to set the right function-pointer for (l)stat every single time. This is not desirable. Furthermore, recurse should be easy to use and not involve trouble finding the right (l)stat-function to do it right. So, what we needed was a stat-argument for each fn(), so it is directly accessible. This was impossible to do though when the fn()'s are still directly called by the programs to "start" the recurse. Thus, the fundamental change is to make recurse() the function to go, while designing the fn()'s in a way they can "live" with st being NULL (we don't want a null-pointer-deref). What you can see in this commit is the result of this work. Why all this trouble instead of using nftw? The special thing about recurse() is that you tell the function when to recurse() in your fn(). You don't need special flags to tell nftw() to skip the subtree, just to give an example. The only single downside to this is that now, you are not allowed to unconditionally call recurse() from your fn(). It has to be a directory. However, that is a cost I think is easily weighed up by the advantages. Another thing is the history: I added a procedure at the end of the outmost recurse to free the history. This way we don't leak memory. A simple optimization on the side: - if (h->dev == st.st_dev && h->ino == st.st_ino) + if (h->ino == st.st_ino && h->dev == st.st_dev) First compare the likely difference in inode-numbers instead of checking the unlikely condition that the device-numbers are different.
2015-03-18 23:53:42 +00:00
recurse(*argv, &n, &r);
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}
}
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
Add *fshut() functions to properly flush file streams This has been a known issue for a long time. Example: printf "word" > /dev/full wouldn't report there's not enough space on the device. This is due to the fact that every libc has internal buffers for stdout which store fragments of written data until they reach a certain size or on some callback to flush them all at once to the kernel. You can force the libc to flush them with fflush(). In case flushing fails, you can check the return value of fflush() and report an error. However, previously, sbase didn't have such checks and without fflush(), the libc silently flushes the buffers on exit without checking the errors. No offense, but there's no way for the libc to report errors in the exit- condition. GNU coreutils solve this by having onexit-callbacks to handle the flushing and report issues, but they have obvious deficiencies. After long discussions on IRC, we came to the conclusion that checking the return value of every io-function would be a bit too much, and having a general-purpose fclose-wrapper would be the best way to go. It turned out that fclose() alone is not enough to detect errors. The right way to do it is to fflush() + check ferror on the fp and then to a fclose(). This is what fshut does and that's how it's done before each return. The return value is obviously affected, reporting an error in case a flush or close failed, but also when reading failed for some reason, the error- state is caught. the !!( ... + ...) construction is used to call all functions inside the brackets and not "terminating" on the first. We want errors to be reported, but there's no reason to stop flushing buffers when one other file buffer has issues. Obviously, functionales come before the flush and ret-logic comes after to prevent early exits as well without reporting warnings if there are any. One more advantage of fshut() is that it is even able to report errors on obscure NFS-setups which the other coreutils are unable to detect, because they only check the return-value of fflush() and fclose(), not ferror() as well.
2015-04-04 19:25:17 +00:00
return fshut(stdout, "<stdout>") || recurse_status;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}
Reference in New Issue Copy Permalink