How to check directory and file sizes in Linux

On Linux systems, disk space often disappears gradually across many directories and files. Checking directory and file sizes makes it possible to spot unexpected growth, clean up large items, and prevent services from failing due to full partitions.

Commands such as ls and stat expose single-file information, but overall disk consumption across entire directory trees is best inspected with du. The du tool walks directories, sums the blocks actually used on disk, and prints per-path usage in formats that are easy to scan, such as human-readable units.

Because du reports allocated space rather than only apparent size, results can differ for sparse files, compressed or copy-on-write filesystems, and bind mounts. Running du on system paths may require elevated permissions and can be intensive on large trees, so limiting recursion depth and summarizing output reduces noise and speeds up inspection.

1. Check the size of a specific file in 1K blocks.

   $ du Documents/random.txt
   16  Documents/random.txt

   Shows disk usage in 1K blocks by default, which may differ slightly from the size reported by ls.

2. Display the size of a specific file in a human-readable format.

   $ du -h Documents/random.txt
   16K Documents/random.txt

   The -h option prints sizes using units such as K, M, and G.

3. Show the size of all files and subdirectories within a directory recursively.

   $ du -h Documents/
   21M Documents/Finance
   4.0K  Documents/Secret/Empty
   40K Documents/Secret
   21M Documents/

   Each line shows the cumulative size of the path on that line, including everything beneath it.

4. Limit the depth of the recursive listing to highlight only top-level directories.

   $ du -h --max-depth=1 Documents/
   21M Documents/Finance
   40K Documents/Secret
   21M Documents/

   The –max-depth=1 option prints sizes for the target directory and its immediate children only.

5. Show folder sizes and include a grand total at the end.

   $ du -hc Documents/
   21M Documents/Finance
   4.0K  Documents/Secret/Empty
   40K Documents/Secret
   21M Documents/
   21M total

   The -c option adds a final total line summarizing all reported entries.

6. Display only the total size of a directory without listing its contents.

   $ du -hs Documents/
   21M Documents/

   The combination of -h and -s produces a single summarized size in human-readable units.

7. Inspect the size of a system directory that requires elevated permissions.

   $ sudo du -hs /var/cache/
   [sudo] password for user:
   117M  /var/cache/

   Using sudo against paths like /var/cache or /var/log ensures all entries can be read and counted.

8. Show non-recursive sizes of all immediate subdirectories under a system path.

   $ sudo du -hs /var/cache/*
   6.2M  /var/cache/apparmor
   16M /var/cache/app-info
   75M /var/cache/apt
   6.1M  /var/cache/cracklib
   32K /var/cache/cups
   5.2M  /var/cache/debconf
   40K /var/cache/dictionaries-common
   2.7M  /var/cache/fontconfig
   2.1M  /var/cache/fwupd
   0 /var/cache/fwupdmgr
   60K /var/cache/ldconfig
   2.1M  /var/cache/man
   8.0K  /var/cache/PackageKit
   8.0K  /var/cache/private
   4.0K  /var/cache/realmd
   2.2M  /var/cache/snapd

   This pattern quickly reveals which subdirectories under /var/cache consume the most space without traversing deeper levels.

9. Find the largest directories under a given path using sorted output.

   $ sudo du -h --max-depth=1 /var/ | sort -h
   4.0K  /var/local
   372M  /var/log
   1.2G  /var/lib
   1.6G  /var/

   Sorting with sort -h orders paths by size so the largest directories appear at the bottom of the list.

10. Review available du options and behavior for more advanced usage.

    $ du --help
    Usage: du [OPTION]... [FILE]...
      or:  du [OPTION]... --files0-from=F
    Summarize disk usage of the set of FILEs, recursively for directories.
    
    Mandatory arguments to long options are mandatory for short options too.
      -0, --null            end each output line with NUL, not newline
      -a, --all             write counts for all files, not just directories
          --apparent-size   print apparent sizes, rather than disk usage; although
                              the apparent size is usually smaller, it may be
                              larger due to holes in ('sparse') files, internal
                              fragmentation, indirect blocks, and the like
      -B, --block-size=SIZE  scale sizes by SIZE before printing them; e.g.,
                               '-BM' prints sizes in units of 1,048,576 bytes;
                               see SIZE format below
      -b, --bytes           equivalent to '--apparent-size --block-size=1'
      -c, --total           produce a grand total
      -D, --dereference-args  dereference only symlinks that are listed on the
                              command line
      -d, --max-depth=N     print the total for a directory (or file, with --all)
                              only if it is N or fewer levels below the command
                              line argument;  --max-depth=0 is the same as
                              --summarize
          --files0-from=F   summarize disk usage of the
                              NUL-terminated file names specified in file F;
                              if F is -, then read names from standard input
      -H                    equivalent to --dereference-args (-D)
      -h, --human-readable  print sizes in human readable format (e.g., 1K 234M 2G)
          --inodes          list inode usage information instead of block usage
      -k                    like --block-size=1K
      -L, --dereference     dereference all symbolic links
      -l, --count-links     count sizes many times if hard linked
      -m                    like --block-size=1M
      -P, --no-dereference  don't follow any symbolic links (this is the default)
      -S, --separate-dirs   for directories do not include size of subdirectories
          --si              like -h, but use powers of 1000 not 1024
      -s, --summarize       display only a total for each argument
      -t, --threshold=SIZE  exclude entries smaller than SIZE if positive,
                              or entries greater than SIZE if negative
          --time            show time of the last modification of any file in the
                              directory, or any of its subdirectories
          --time=WORD       show time as WORD instead of modification time:
                              atime, access, use, ctime or status
          --time-style=STYLE  show times using STYLE, which can be:
                                full-iso, long-iso, iso, or +FORMAT;
                                FORMAT is interpreted like in 'date'
      -X, --exclude-from=FILE  exclude files that match any pattern in FILE
          --exclude=PATTERN    exclude files that match PATTERN
      -x, --one-file-system    skip directories on different file systems
          --help     display this help and exit
          --version  output version information and exit
    
    Display values are in units of the first available SIZE from --block-size,
    and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.
    Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).
    
    The SIZE argument is an integer and optional unit (example: 10K is 10*1024).
    Units are K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000).
    Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
    
    GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
    Full documentation <https://www.gnu.org/software/coreutils/du>
    or available locally via: info '(coreutils) du invocation'

    Related: du man page