/*
* du - print disk usage
*/
#include <u.h>
#include <libc.h>
#include <String.h>

extern  vlong   du(char*, Dir*);
extern  void    err(char*);
extern  vlong   blkmultiple(vlong);
extern  int     seen(Dir*);
extern  int     warn(char*);

enum {
       Vkilo = 1024LL,
};

/* rounding up, how many units does amt occupy? */
#define HOWMANY(amt, unit)      (((amt)+(unit)-1) / (unit))
#define ROUNDUP(amt, unit)      (HOWMANY(amt, unit) * (unit))

int     aflag;
int     autoscale;
int     fflag;
int     fltflag;
int     qflag;
int     readflg;
int     sflag;
int     tflag;
int     uflag;

char    *fmt = "%llud\t%q\n";
char    *readbuf;
vlong   blocksize = Vkilo;      /* actually more likely to be 4K or 8K */
vlong   unit;                   /* scale factor for output */

static char *pfxes[] = {        /* SI prefixes for units > 1 */
       "",
       "k", "M", "G",
       "T", "P", "E",
       "Z", "Y",
       nil,
};

void
usage(void)
{
       fprint(2, "usage: du [-aefhnqstu] [-b size] [-p si-pfx] [file ...]\n");
       exits("usage");
}

void
printamt(vlong amt, char *name)
{
       if (readflg)
               return;
       if (autoscale) {
               int scale = 0;
               double val = (double)amt/unit;

               while (fabs(val) >= 1024 && scale < nelem(pfxes)-1) {
                       scale++;
                       val /= 1024;
               }
               print("%.6g%s\t%q\n", val, pfxes[scale], name);
       } else if (fltflag)
               print("%.6g\t%q\n", (double)amt/unit, name);
       else
               print(fmt, HOWMANY(amt, unit), name);
}

void
main(int argc, char *argv[])
{
       int i, scale;
       char *s, *ss, *name;

       doquote = needsrcquote;
       quotefmtinstall();

       ARGBEGIN {
       case 'a':       /* all files */
               aflag = 1;
               break;
       case 'b':       /* block size */
               s = ARGF();
               if(s) {
                       blocksize = strtoul(s, &ss, 0);
                       if(s == ss)
                               blocksize = 1;
                       while(*ss++ == 'k')
                               blocksize *= 1024;
               }
               break;
       case 'e':       /* print in %g notation */
               fltflag = 1;
               break;
       case 'f':       /* don't print warnings */
               fflag = 1;
               break;
       case 'h':       /* similar to -h in bsd but more precise */
               autoscale = 1;
               break;
       case 'n':       /* all files, number of bytes */
               aflag = 1;
               blocksize = 1;
               unit = 1;
               break;
       case 'p':
               s = ARGF();
               if(s) {
                       for (scale = 0; pfxes[scale] != nil; scale++)
                               if (cistrcmp(s, pfxes[scale]) == 0)
                                       break;
                       if (pfxes[scale] == nil)
                               sysfatal("unknown suffix %s", s);
                       unit = 1;
                       while (scale-- > 0)
                               unit *= Vkilo;
               }
               break;
       case 'q':       /* qid */
               fmt = "%.16llux\t%q\n";
               qflag = 1;
               break;
       case 'r':
               /* undocumented: just read & ignore every block of every file */
               readflg = 1;
               break;
       case 's':       /* only top level */
               sflag = 1;
               break;
       case 't':       /* return modified/accessed time */
               tflag = 1;
               break;
       case 'u':       /* accessed time */
               uflag = 1;
               break;
       default:
               usage();
       } ARGEND

       if (unit == 0)
               if (qflag || tflag || uflag || autoscale)
                       unit = 1;
               else
                       unit = Vkilo;
       if (blocksize < 1)
               blocksize = 1;

       if (readflg) {
               readbuf = malloc(blocksize);
               if (readbuf == nil)
                       sysfatal("out of memory");
       }
       if(argc==0)
               printamt(du(".", dirstat(".")), ".");
       else
               for(i=0; i<argc; i++) {
                       name = argv[i];
                       printamt(du(name, dirstat(name)), name);
               }
       exits(0);
}

vlong
dirval(Dir *d, vlong size)
{
       if(qflag)
               return d->qid.path;
       else if(tflag) {
               if(uflag)
                       return d->atime;
               return d->mtime;
       } else
               return size;
}

void
readfile(char *name)
{
       int n, fd = open(name, OREAD);

       if(fd < 0) {
               warn(name);
               return;
       }
       while ((n = read(fd, readbuf, blocksize)) > 0)
               continue;
       if (n < 0)
               warn(name);
       close(fd);
}

vlong
dufile(char *name, Dir *d)
{
       vlong t = blkmultiple(d->length);

       if(aflag || readflg) {
               String *file = s_copy(name);

               s_append(file, "/");
               s_append(file, d->name);
               if (readflg)
                       readfile(s_to_c(file));
               t = dirval(d, t);
               printamt(t, s_to_c(file));
               s_free(file);
       }
       return t;
}

vlong
du(char *name, Dir *dir)
{
       int fd, i, n;
       Dir *buf, *d;
       String *file;
       vlong nk, t;

       if(dir == nil)
               return warn(name);

       if((dir->qid.type&QTDIR) == 0)
               return dirval(dir, blkmultiple(dir->length));

       fd = open(name, OREAD);
       if(fd < 0)
               return warn(name);
       nk = 0;
       while((n=dirread(fd, &buf)) > 0) {
               d = buf;
               for(i = n; i > 0; i--, d++) {
                       if((d->qid.type&QTDIR) == 0) {
                               nk += dufile(name, d);
                               continue;
                       }

                       if(strcmp(d->name, ".") == 0 ||
                          strcmp(d->name, "..") == 0 ||
                          /* !readflg && */ seen(d))
                               continue;       /* don't get stuck */

                       file = s_copy(name);
                       s_append(file, "/");
                       s_append(file, d->name);

                       t = du(s_to_c(file), d);

                       nk += t;
                       t = dirval(d, t);
                       if(!sflag)
                               printamt(t, s_to_c(file));
                       s_free(file);
               }
               free(buf);
       }
       if(n < 0)
               warn(name);
       close(fd);
       return dirval(dir, nk);
}

#define NCACHE  256     /* must be power of two */

typedef struct
{
       Dir*    cache;
       int     n;
       int     max;
} Cache;
Cache cache[NCACHE];

int
seen(Dir *dir)
{
       Dir *dp;
       int i;
       Cache *c;

       c = &cache[dir->qid.path&(NCACHE-1)];
       dp = c->cache;
       for(i=0; i<c->n; i++, dp++)
               if(dir->qid.path == dp->qid.path &&
                  dir->type == dp->type &&
                  dir->dev == dp->dev)
                       return 1;
       if(c->n == c->max){
               if (c->max == 0)
                       c->max = 8;
               else
                       c->max += c->max/2;
               c->cache = realloc(c->cache, c->max*sizeof(Dir));
               if(c->cache == nil)
                       err("malloc failure");
       }
       c->cache[c->n++] = *dir;
       return 0;
}

void
err(char *s)
{
       fprint(2, "du: %s: %r\n", s);
       exits(s);
}

int
warn(char *s)
{
       if(fflag == 0)
               fprint(2, "du: %s: %r\n", s);
       return 0;
}

/* round up n to nearest block */
vlong
blkmultiple(vlong n)
{
       if(blocksize == 1)              /* no quantization */
               return n;
       return ROUNDUP(n, blocksize);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.