| /* du.c - disk usage program. |
| * |
| * Copyright 2012 Ashwini Kumar <ak.ashwini@gmail.com> |
| * |
| * See http://opengroup.org/onlinepubs/9699919799/utilities/du.html |
| |
| USE_DU(NEWTOY(du, "d#<0hmlcaHkLsx", TOYFLAG_USR|TOYFLAG_BIN)) |
| |
| config DU |
| bool "du" |
| default y |
| help |
| usage: du [-d N] [-askxHLlmc] [file...] |
| |
| Estimate file space usage (default in unit of 512 blocks). |
| -a Show all file sizes |
| -H Follow symlinks on cmdline |
| -L Follow all symlinks |
| -k Show size in units of 1024. |
| -s Show only the total Size for each file specified |
| -x Estimate size only on the same device |
| -c Print total size of all arguments |
| -d N Limit output to directories (and files with -a) of depth < N |
| -l Count sizes many times if hard linked |
| -h Sizes in human readable format (e.g., 1K 243M 2G ) |
| -m Sizes in megabytes |
| */ |
| |
| #define FOR_du |
| #include "toys.h" |
| |
| GLOBALS( |
| long maxdepth; |
| long depth; |
| long *dirsum; |
| long total; |
| dev_t st_dev; |
| struct arg_list *inodes; |
| ) |
| |
| typedef struct node_size { |
| struct dirtree *node; |
| long size; |
| }node_size; |
| |
| typedef struct inode_ent { |
| ino_t ino; |
| dev_t dev; |
| }inode_ent_t; |
| |
| /* |
| * Adding '/' to the name if name is '.' or '..' |
| */ |
| |
| char *make_pathproper(char *str) |
| { |
| char *path = str; |
| switch(strlen(str)) { |
| case 1: |
| if(str[0] == '.') path = xstrdup("./"); |
| break; |
| case 2: |
| if(str[0] == '.' && str[1] == '.') path = xstrdup("../"); |
| break; |
| default: |
| break; |
| } |
| return path; |
| } |
| |
| /* |
| * Print the size of the given entry in specified format, default in blocks of 512 bytes |
| */ |
| void print(long size, char* name) |
| { |
| unsigned long long tempsize = (unsigned long long)size * 512; |
| unsigned long unit = 512; |
| char *sizestr = NULL; |
| if(TT.depth > TT.maxdepth) return; |
| if(toys.optflags & FLAG_h) unit = 0; |
| if(toys.optflags & FLAG_k) unit = 1024; |
| if(toys.optflags & FLAG_m) unit = 1024*1024; |
| sizestr = make_human_readable(tempsize, unit); //make human readable string, depending upon unit size. |
| xprintf("%s\t%s\n",sizestr, name); |
| free(sizestr); |
| } |
| |
| /* |
| * free the inodes which are stored for hard link reference |
| */ |
| void free_inodes(void *data) |
| { |
| void *arg = ((struct arg_list*)data)->arg; |
| if(arg) free(arg); |
| free(data); |
| } |
| |
| /* |
| * allocate and add a node to the list |
| */ |
| static void llist_add_inode(struct arg_list **old, void *data) |
| { |
| struct arg_list *new = xmalloc(sizeof(struct arg_list)); |
| |
| new->arg = (char*)data; |
| new->next = *old; |
| *old = new; |
| } |
| |
| /* |
| * check if the given stat entry is already there in list or not |
| */ |
| int is_inode_present(struct stat *st) |
| { |
| struct arg_list *temparg = NULL; |
| inode_ent_t *ent = NULL; |
| if(!TT.inodes) return 0; |
| for(temparg = TT.inodes; temparg; temparg = (struct arg_list *)temparg->next) { |
| ent = (inode_ent_t*)temparg->arg; |
| if(ent && ent->ino == st->st_ino && ent->dev == st->st_dev) return 1; |
| } |
| return 0; |
| } |
| |
| /* |
| * Compute the size of the node |
| */ |
| int do_du(struct dirtree *node) |
| { |
| inode_ent_t *ino_details = NULL; |
| node_size *nd = NULL; |
| if(!dirtree_notdotdot(node)) return 0; |
| if((toys.optflags & FLAG_x) && (TT.st_dev != node->st.st_dev)) //if file not on same device, don't count size |
| return DIRTREE_RECURSE; |
| |
| if(!(toys.optflags & FLAG_l) && node->st.st_nlink > 1 && !node->extra) { //keeping reference for hard links |
| if(is_inode_present(&node->st)) return DIRTREE_RECURSE; |
| ino_details = xzalloc(sizeof(inode_ent_t)); |
| ino_details->ino = node->st.st_ino; |
| ino_details->dev = node->st.st_dev; |
| llist_add_inode(&TT.inodes, (void*)ino_details); |
| } |
| |
| if(S_ISDIR(node->st.st_mode)) { |
| if(!(node->extra && (long)((node_size*)(node->extra))->node == (long)node)) { |
| nd = xzalloc(sizeof(node_size)); |
| nd->node = node; |
| nd->size = 0; |
| TT.dirsum = (long*)&(nd->size); |
| node->extra = (long)nd; |
| *TT.dirsum = 0; |
| TT.depth++; |
| return (DIRTREE_RECURSE|DIRTREE_COMEAGAIN | ((toys.optflags & FLAG_L) ? DIRTREE_SYMFOLLOW : 0)); //DIRTREE_COMEAGAIN to comeback and print the entry. |
| } |
| else if(node->extra) { //extra is set for a returning DIR entry. |
| long offset = 0; |
| nd = (node_size*)node->extra; |
| offset = nd->size; |
| nd->size += node->st.st_blocks; |
| TT.depth--; |
| if(!(toys.optflags & FLAG_s)) |
| print(*TT.dirsum, dirtree_path(node, NULL)); |
| if((node->parent) && (node->parent->extra)) { |
| /* when returning from internal directory, get the saved size of the parent and continue from there */ |
| nd = (node_size*)node->parent->extra; |
| TT.dirsum = (long*)&(nd->size); |
| *TT.dirsum += offset; |
| *TT.dirsum += node->st.st_blocks; |
| return DIRTREE_RECURSE; |
| } |
| else if(!node->parent) { |
| /*if node has no parent, it means it is the top in the tree, stop recursing here */ |
| TT.total += *TT.dirsum; |
| if((toys.optflags & FLAG_s)) |
| print(*TT.dirsum, dirtree_path(node, NULL)); |
| return 0; |
| } |
| } |
| } |
| else if(!(node->parent)) { |
| /* this is the file specified on cmdline */ |
| TT.total += node->st.st_blocks; |
| print(node->st.st_blocks, dirtree_path(node, NULL)); |
| return 0; |
| } |
| if(TT.dirsum) *TT.dirsum += node->st.st_blocks; |
| if(toys.optflags & FLAG_a && !(toys.optflags & FLAG_s)) |
| print(node->st.st_blocks, dirtree_path(node, NULL)); |
| return DIRTREE_RECURSE; |
| } |
| |
| /* |
| * DU utility main function |
| */ |
| void du_main(void) |
| { |
| int symfollow = toys.optflags & (FLAG_H | FLAG_L); |
| TT.total = 0; |
| TT.inodes = NULL; |
| |
| if(!(toys.optflags & FLAG_d)) TT.maxdepth = INT_MAX; |
| if(toys.optc == 0) toys.optargs[0] = "./"; |
| while(*toys.optargs) { |
| TT.depth = 0; |
| char *path = make_pathproper(*toys.optargs); |
| struct dirtree *root = dirtree_add_node(0, path, symfollow); |
| if(root) { |
| TT.st_dev = root->st.st_dev; |
| dirtree_handle_callback(root, do_du); // recurse thru the DIR children. |
| } |
| toys.optargs++; |
| } |
| if(TT.inodes) llist_traverse(TT.inodes, free_inodes); //free the stored nodes |
| if(toys.optflags & FLAG_c) print(TT.total, "total"); |
| } |