From a58cdb6355c62a57e2f82ec495deb728f80365ee Mon Sep 17 00:00:00 2001 From: kuben Date: Sun, 3 Nov 2019 14:28:22 +0100 Subject: [PATCH] Add scripts --- scripts/clean-old-packages.sh | 11 + scripts/displays.sh | 46 ++ scripts/health/du.c | 1140 +++++++++++++++++++++++++++++++++ scripts/health/health.c | 220 +++++++ scripts/health/health.h | 43 ++ scripts/health/makefile | 24 + scripts/health/utils.c | 87 +++ scripts/health/utils.h | 25 + scripts/set_bg.sh | 24 + 9 files changed, 1620 insertions(+) create mode 100644 scripts/clean-old-packages.sh create mode 100755 scripts/displays.sh create mode 100644 scripts/health/du.c create mode 100644 scripts/health/health.c create mode 100644 scripts/health/health.h create mode 100755 scripts/health/makefile create mode 100644 scripts/health/utils.c create mode 100644 scripts/health/utils.h create mode 100755 scripts/set_bg.sh diff --git a/scripts/clean-old-packages.sh b/scripts/clean-old-packages.sh new file mode 100644 index 0000000..6c442f9 --- /dev/null +++ b/scripts/clean-old-packages.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +# To generate list of large packages +# pacman -Qi | grep 'Name\|Size\|Description' | cut -d: -f2 | paste - - - | awk -F'\t' 'BEGIN{ s["MiB"]=1024; s["KiB"]=1;} {split($3, a, " "); print a[1] * s[a[2]], "KiB", $1}' | sort -n + +LARGE_PKGS='linux jdk10-openjdk jre8-openjdk-headless jre10-openjdk-headless gimp gcc-list webkit2gtk gcc python chromium dropbox spotify mono bazel valgrind texlive-core linux-firmware' + +echo -n "==> Looking for old packages to prune" +paccache -rk1 +echo -n "==> Looking for old large packages to prune" +paccache -rk0 $LARGE_PKGS diff --git a/scripts/displays.sh b/scripts/displays.sh new file mode 100755 index 0000000..3d1a334 --- /dev/null +++ b/scripts/displays.sh @@ -0,0 +1,46 @@ +#!/bin/bash +#$1 is - + +#echo "DISP:eDP1" +#exit 0 + +function primary() { + xrandr | grep primary | awk '{print $1}' +} + +#displays=($(xrandr | sed -rn 's/(^|(.* ))([^ ]*) connected(( .*)|$)/\3/g; T; p' )) +displays=$(xrandr | grep " connected" | awk '{print $1}') +case "$1" in + "connected") + echo "$displays" +# for i in "${displays[@]}"; do +# echo "$i" +# done + ;; + "lemonbar") + echo "DISP ${displays[@]}" | sed "s/ /:/g" + ;; + *) + # -F Fix strings, -x exactly, -q quiet + if echo "$displays" | grep -Fqx "$1"; then + case "$2" in + "off") + action="--off" + ;; + "mirror") + action="--same-as $(primary)" + ;; + "left") + action="--left-of $(primary) --auto" + ;; + "right") + action="--right-of $(primary) --auto" + ;; + *) + exit 1 + ;; + esac + xrandr --output $1 $action + fi +esac + diff --git a/scripts/health/du.c b/scripts/health/du.c new file mode 100644 index 0000000..4b7192c --- /dev/null +++ b/scripts/health/du.c @@ -0,0 +1,1140 @@ +/* du -- summarize disk usage + Copyright (C) 1988-2019 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* Differences from the Unix du: + * Doesn't simply ignore the names of regular files given as arguments + when -a is given. + + By tege@sics.se, Torbjorn Granlund, + and djm@ai.mit.edu, David MacKenzie. + Variable blocks added by lm@sgi.com and eggert@twinsun.com. + Rewritten to use nftw, then to use fts by Jim Meyering. */ + +#include +#include +#include +#include +#include "system.h" +#include "argmatch.h" +#include "argv-iter.h" +#include "di-set.h" +#include "die.h" +#include "error.h" +#include "exclude.h" +#include "fprintftime.h" +#include "human.h" +#include "mountlist.h" +#include "quote.h" +#include "stat-size.h" +#include "stat-time.h" +#include "stdio--.h" +#include "xfts.h" +#include "xstrtol.h" + +extern bool fts_debug; + +/* The official name of this program (e.g., no 'g' prefix). */ +#define PROGRAM_NAME "du" + +#define AUTHORS \ + proper_name ("Torbjorn Granlund"), \ + proper_name ("David MacKenzie"), \ + proper_name ("Paul Eggert"), \ + proper_name ("Jim Meyering") + +#if DU_DEBUG +# define FTS_CROSS_CHECK(Fts) fts_cross_check (Fts) +#else +# define FTS_CROSS_CHECK(Fts) +#endif + +/* A set of dev/ino pairs to help identify files and directories + whose sizes have already been counted. */ +static struct di_set *di_files; + +/* A set containing a dev/ino pair for each local mount point directory. */ +static struct di_set *di_mnt; + +/* Keep track of the preceding "level" (depth in hierarchy) + from one call of process_file to the next. */ +static size_t prev_level; + +/* Define a class for collecting directory information. */ +struct duinfo +{ + /* Size of files in directory. */ + uintmax_t size; + + /* Number of inodes in directory. */ + uintmax_t inodes; + + /* Latest timestamp found. If tmax.tv_sec == TYPE_MINIMUM (time_t) + && tmax.tv_nsec < 0, no timestamp has been found. */ + struct timespec tmax; +}; + +/* Initialize directory data. */ +static inline void +duinfo_init (struct duinfo *a) +{ + a->size = 0; + a->inodes = 0; + a->tmax.tv_sec = TYPE_MINIMUM (time_t); + a->tmax.tv_nsec = -1; +} + +/* Set directory data. */ +static inline void +duinfo_set (struct duinfo *a, uintmax_t size, struct timespec tmax) +{ + a->size = size; + a->inodes = 1; + a->tmax = tmax; +} + +/* Accumulate directory data. */ +static inline void +duinfo_add (struct duinfo *a, struct duinfo const *b) +{ + uintmax_t sum = a->size + b->size; + a->size = a->size <= sum ? sum : UINTMAX_MAX; + a->inodes = a->inodes + b->inodes; + if (timespec_cmp (a->tmax, b->tmax) < 0) + a->tmax = b->tmax; +} + +/* A structure for per-directory level information. */ +struct dulevel +{ + /* Entries in this directory. */ + struct duinfo ent; + + /* Total for subdirectories. */ + struct duinfo subdir; +}; + +/* If true, display counts for all files, not just directories. */ +static bool opt_all = false; + +/* If true, rather than using the disk usage of each file, + use the apparent size (a la stat.st_size). */ +static bool apparent_size = false; + +/* If true, count each hard link of files with multiple links. */ +static bool opt_count_all = false; + +/* If true, hash all files to look for hard links. */ +static bool hash_all; + +/* If true, output the NUL byte instead of a newline at the end of each line. */ +static bool opt_nul_terminate_output = false; + +/* If true, print a grand total at the end. */ +static bool print_grand_total = false; + +/* If nonzero, do not add sizes of subdirectories. */ +static bool opt_separate_dirs = false; + +/* Show the total for each directory (and file if --all) that is at + most MAX_DEPTH levels down from the root of the hierarchy. The root + is at level 0, so 'du --max-depth=0' is equivalent to 'du -s'. */ +static size_t max_depth = SIZE_MAX; + +/* Only output entries with at least this SIZE if positive, + or at most if negative. See --threshold option. */ +static intmax_t opt_threshold = 0; + +/* Human-readable options for output. */ +static int human_output_opts; + +/* Output inodes count instead of blocks used. */ +static bool opt_inodes = false; + +/* If true, print most recently modified date, using the specified format. */ +static bool opt_time = false; + +/* Type of time to display. controlled by --time. */ + +enum time_type + { + time_mtime, /* default */ + time_ctime, + time_atime + }; + +static enum time_type time_type = time_mtime; + +/* User specified date / time style */ +static char const *time_style = NULL; + +/* Format used to display date / time. Controlled by --time-style */ +static char const *time_format = NULL; + +/* The local time zone rules, as per the TZ environment variable. */ +static timezone_t localtz; + +/* The units to use when printing sizes. */ +static uintmax_t output_block_size; + +/* File name patterns to exclude. */ +static struct exclude *exclude; + +/* Grand total size of all args, in bytes. Also latest modified date. */ +static struct duinfo tot_dui; + +#define IS_DIR_TYPE(Type) \ + ((Type) == FTS_DP \ + || (Type) == FTS_DNR) + +/* For long options that have no equivalent short option, use a + non-character as a pseudo short option, starting with CHAR_MAX + 1. */ +enum +{ + APPARENT_SIZE_OPTION = CHAR_MAX + 1, + EXCLUDE_OPTION, + FILES0_FROM_OPTION, + HUMAN_SI_OPTION, + FTS_DEBUG, + TIME_OPTION, + TIME_STYLE_OPTION, + INODES_OPTION +}; + +static struct option const long_options[] = +{ + {"all", no_argument, NULL, 'a'}, + {"apparent-size", no_argument, NULL, APPARENT_SIZE_OPTION}, + {"block-size", required_argument, NULL, 'B'}, + {"bytes", no_argument, NULL, 'b'}, + {"count-links", no_argument, NULL, 'l'}, + /* {"-debug", no_argument, NULL, FTS_DEBUG}, */ + {"dereference", no_argument, NULL, 'L'}, + {"dereference-args", no_argument, NULL, 'D'}, + {"exclude", required_argument, NULL, EXCLUDE_OPTION}, + {"exclude-from", required_argument, NULL, 'X'}, + {"files0-from", required_argument, NULL, FILES0_FROM_OPTION}, + {"human-readable", no_argument, NULL, 'h'}, + {"inodes", no_argument, NULL, INODES_OPTION}, + {"si", no_argument, NULL, HUMAN_SI_OPTION}, + {"max-depth", required_argument, NULL, 'd'}, + {"null", no_argument, NULL, '0'}, + {"no-dereference", no_argument, NULL, 'P'}, + {"one-file-system", no_argument, NULL, 'x'}, + {"separate-dirs", no_argument, NULL, 'S'}, + {"summarize", no_argument, NULL, 's'}, + {"total", no_argument, NULL, 'c'}, + {"threshold", required_argument, NULL, 't'}, + {"time", optional_argument, NULL, TIME_OPTION}, + {"time-style", required_argument, NULL, TIME_STYLE_OPTION}, + {GETOPT_HELP_OPTION_DECL}, + {GETOPT_VERSION_OPTION_DECL}, + {NULL, 0, NULL, 0} +}; + +static char const *const time_args[] = +{ + "atime", "access", "use", "ctime", "status", NULL +}; +static enum time_type const time_types[] = +{ + time_atime, time_atime, time_atime, time_ctime, time_ctime +}; +ARGMATCH_VERIFY (time_args, time_types); + +/* 'full-iso' uses full ISO-style dates and times. 'long-iso' uses longer + ISO-style timestamps, though shorter than 'full-iso'. 'iso' uses shorter + ISO-style timestamps. */ +enum time_style + { + full_iso_time_style, /* --time-style=full-iso */ + long_iso_time_style, /* --time-style=long-iso */ + iso_time_style /* --time-style=iso */ + }; + +static char const *const time_style_args[] = +{ + "full-iso", "long-iso", "iso", NULL +}; +static enum time_style const time_style_types[] = +{ + full_iso_time_style, long_iso_time_style, iso_time_style +}; +ARGMATCH_VERIFY (time_style_args, time_style_types); + +void +usage (int status) +{ + if (status != EXIT_SUCCESS) + emit_try_help (); + else + { + printf (_("\ +Usage: %s [OPTION]... [FILE]...\n\ + or: %s [OPTION]... --files0-from=F\n\ +"), program_name, program_name); + fputs (_("\ +Summarize disk usage of the set of FILEs, recursively for directories.\n\ +"), stdout); + + emit_mandatory_arg_note (); + + fputs (_("\ + -0, --null end each output line with NUL, not newline\n\ + -a, --all write counts for all files, not just directories\n\ + --apparent-size print apparent sizes, rather than disk usage; although\ +\n\ + the apparent size is usually smaller, it may be\n\ + larger due to holes in ('sparse') files, internal\n\ + fragmentation, indirect blocks, and the like\n\ +"), stdout); + fputs (_("\ + -B, --block-size=SIZE scale sizes by SIZE before printing them; e.g.,\n\ + '-BM' prints sizes in units of 1,048,576 bytes;\n\ + see SIZE format below\n\ + -b, --bytes equivalent to '--apparent-size --block-size=1'\n\ + -c, --total produce a grand total\n\ + -D, --dereference-args dereference only symlinks that are listed on the\n\ + command line\n\ + -d, --max-depth=N print the total for a directory (or file, with --all)\n\ + only if it is N or fewer levels below the command\n\ + line argument; --max-depth=0 is the same as\n\ + --summarize\n\ +"), stdout); + fputs (_("\ + --files0-from=F summarize disk usage of the\n\ + NUL-terminated file names specified in file F;\n\ + if F is -, then read names from standard input\n\ + -H equivalent to --dereference-args (-D)\n\ + -h, --human-readable print sizes in human readable format (e.g., 1K 234M 2G)\ +\n\ + --inodes list inode usage information instead of block usage\n\ +"), stdout); + fputs (_("\ + -k like --block-size=1K\n\ + -L, --dereference dereference all symbolic links\n\ + -l, --count-links count sizes many times if hard linked\n\ + -m like --block-size=1M\n\ +"), stdout); + fputs (_("\ + -P, --no-dereference don't follow any symbolic links (this is the default)\n\ + -S, --separate-dirs for directories do not include size of subdirectories\n\ + --si like -h, but use powers of 1000 not 1024\n\ + -s, --summarize display only a total for each argument\n\ +"), stdout); + fputs (_("\ + -t, --threshold=SIZE exclude entries smaller than SIZE if positive,\n\ + or entries greater than SIZE if negative\n\ + --time show time of the last modification of any file in the\n\ + directory, or any of its subdirectories\n\ + --time=WORD show time as WORD instead of modification time:\n\ + atime, access, use, ctime or status\n\ + --time-style=STYLE show times using STYLE, which can be:\n\ + full-iso, long-iso, iso, or +FORMAT;\n\ + FORMAT is interpreted like in 'date'\n\ +"), stdout); + fputs (_("\ + -X, --exclude-from=FILE exclude files that match any pattern in FILE\n\ + --exclude=PATTERN exclude files that match PATTERN\n\ + -x, --one-file-system skip directories on different file systems\n\ +"), stdout); + fputs (HELP_OPTION_DESCRIPTION, stdout); + fputs (VERSION_OPTION_DESCRIPTION, stdout); + emit_blocksize_note ("DU"); + emit_size_note (); + emit_ancillary_info (PROGRAM_NAME); + } + exit (status); +} + +/* Try to insert the INO/DEV pair into DI_SET. + Return true if the pair is successfully inserted, + false if the pair was already there. */ +static bool +hash_ins (struct di_set *di_set, ino_t ino, dev_t dev) +{ + int inserted = di_set_insert (di_set, dev, ino); + if (inserted < 0) + xalloc_die (); + return inserted; +} + +/* FIXME: this code is nearly identical to code in date.c */ +/* Display the date and time in WHEN according to the format specified + in FORMAT. */ + +static void +show_date (const char *format, struct timespec when, timezone_t tz) +{ + struct tm tm; + if (localtime_rz (tz, &when.tv_sec, &tm)) + fprintftime (stdout, format, &tm, tz, when.tv_nsec); + else + { + char buf[INT_BUFSIZE_BOUND (intmax_t)]; + char *when_str = timetostr (when.tv_sec, buf); + error (0, 0, _("time %s is out of range"), quote (when_str)); + fputs (when_str, stdout); + } +} + +/* Print N_BYTES. Convert it to a readable value before printing. */ + +static void +print_only_size (uintmax_t n_bytes) +{ + char buf[LONGEST_HUMAN_READABLE + 1]; + fputs ((n_bytes == UINTMAX_MAX + ? _("Infinity") + : human_readable (n_bytes, buf, human_output_opts, + 1, output_block_size)), + stdout); +} + +/* Print size (and optionally time) indicated by *PDUI, followed by STRING. */ + +static void +print_size (const struct duinfo *pdui, const char *string) +{ + print_only_size (opt_inodes + ? pdui->inodes + : pdui->size); + + if (opt_time) + { + putchar ('\t'); + show_date (time_format, pdui->tmax, localtz); + } + printf ("\t%s%c", string, opt_nul_terminate_output ? '\0' : '\n'); + fflush (stdout); +} + +/* Fill the di_mnt set with local mount point dev/ino pairs. */ + +static void +fill_mount_table (void) +{ + struct mount_entry *mnt_ent = read_file_system_list (false); + while (mnt_ent) + { + struct mount_entry *mnt_free; + if (!mnt_ent->me_remote && !mnt_ent->me_dummy) + { + struct stat buf; + if (!stat (mnt_ent->me_mountdir, &buf)) + hash_ins (di_mnt, buf.st_ino, buf.st_dev); + else + { + /* Ignore stat failure. False positives are too common. + E.g., "Permission denied" on /run/user//gvfs. */ + } + } + + mnt_free = mnt_ent; + mnt_ent = mnt_ent->me_next; + free_mount_entry (mnt_free); + } +} + +/* This function checks whether any of the directories in the cycle that + fts detected is a mount point. */ + +static bool +mount_point_in_fts_cycle (FTSENT const *ent) +{ + FTSENT const *cycle_ent = ent->fts_cycle; + + if (!di_mnt) + { + /* Initialize the set of dev,inode pairs. */ + di_mnt = di_set_alloc (); + if (!di_mnt) + xalloc_die (); + + fill_mount_table (); + } + + while (ent && ent != cycle_ent) + { + if (di_set_lookup (di_mnt, ent->fts_statp->st_dev, + ent->fts_statp->st_ino) > 0) + { + return true; + } + ent = ent->fts_parent; + } + + return false; +} + +/* This function is called once for every file system object that fts + encounters. fts does a depth-first traversal. This function knows + that and accumulates per-directory totals based on changes in + the depth of the current entry. It returns true on success. */ + +static bool +process_file (FTS *fts, FTSENT *ent) +{ + bool ok = true; + struct duinfo dui; + struct duinfo dui_to_print; + size_t level; + static size_t n_alloc; + /* First element of the structure contains: + The sum of the st_size values of all entries in the single directory + at the corresponding level. Although this does include the st_size + corresponding to each subdirectory, it does not include the size of + any file in a subdirectory. Also corresponding last modified date. + Second element of the structure contains: + The sum of the sizes of all entries in the hierarchy at or below the + directory at the specified level. */ + static struct dulevel *dulvl; + + const char *file = ent->fts_path; + const struct stat *sb = ent->fts_statp; + int info = ent->fts_info; + + if (info == FTS_DNR) + { + /* An error occurred, but the size is known, so count it. */ + error (0, ent->fts_errno, _("cannot read directory %s"), quoteaf (file)); + ok = false; + } + else if (info != FTS_DP) + { + bool excluded = excluded_file_name (exclude, file); + if (! excluded) + { + /* Make the stat buffer *SB valid, or fail noisily. */ + + if (info == FTS_NSOK) + { + fts_set (fts, ent, FTS_AGAIN); + FTSENT const *e = fts_read (fts); + assert (e == ent); + info = ent->fts_info; + } + + if (info == FTS_NS || info == FTS_SLNONE) + { + error (0, ent->fts_errno, _("cannot access %s"), quoteaf (file)); + return false; + } + + /* The --one-file-system (-x) option cannot exclude anything + specified on the command-line. By definition, it can exclude + a file or directory only when its device number is different + from that of its just-processed parent directory, and du does + not process the parent of a command-line argument. */ + if (fts->fts_options & FTS_XDEV + && FTS_ROOTLEVEL < ent->fts_level + && fts->fts_dev != sb->st_dev) + excluded = true; + } + + if (excluded + || (! opt_count_all + && (hash_all || (! S_ISDIR (sb->st_mode) && 1 < sb->st_nlink)) + && ! hash_ins (di_files, sb->st_ino, sb->st_dev))) + { + /* If ignoring a directory in preorder, skip its children. + Ignore the next fts_read output too, as it's a postorder + visit to the same directory. */ + if (info == FTS_D) + { + fts_set (fts, ent, FTS_SKIP); + FTSENT const *e = fts_read (fts); + assert (e == ent); + } + + return true; + } + + switch (info) + { + case FTS_D: + return true; + + case FTS_ERR: + /* An error occurred, but the size is known, so count it. */ + error (0, ent->fts_errno, "%s", quotef (file)); + ok = false; + break; + + case FTS_DC: + /* If not following symlinks and not a (bind) mount point. */ + if (cycle_warning_required (fts, ent) + && ! mount_point_in_fts_cycle (ent)) + { + emit_cycle_warning (file); + return false; + } + return true; + } + } + + duinfo_set (&dui, + (apparent_size + ? MAX (0, sb->st_size) + : (uintmax_t) ST_NBLOCKS (*sb) * ST_NBLOCKSIZE), + (time_type == time_mtime ? get_stat_mtime (sb) + : time_type == time_atime ? get_stat_atime (sb) + : get_stat_ctime (sb))); + + level = ent->fts_level; + dui_to_print = dui; + + if (n_alloc == 0) + { + n_alloc = level + 10; + dulvl = xcalloc (n_alloc, sizeof *dulvl); + } + else + { + if (level == prev_level) + { + /* This is usually the most common case. Do nothing. */ + } + else if (level > prev_level) + { + /* Descending the hierarchy. + Clear the accumulators for *all* levels between prev_level + and the current one. The depth may change dramatically, + e.g., from 1 to 10. */ + + if (n_alloc <= level) + { + dulvl = xnrealloc (dulvl, level, 2 * sizeof *dulvl); + n_alloc = level * 2; + } + + for (size_t i = prev_level + 1; i <= level; i++) + { + duinfo_init (&dulvl[i].ent); + duinfo_init (&dulvl[i].subdir); + } + } + else /* level < prev_level */ + { + /* Ascending the hierarchy. + Process a directory only after all entries in that + directory have been processed. When the depth decreases, + propagate sums from the children (prev_level) to the parent. + Here, the current level is always one smaller than the + previous one. */ + assert (level == prev_level - 1); + duinfo_add (&dui_to_print, &dulvl[prev_level].ent); + if (!opt_separate_dirs) + duinfo_add (&dui_to_print, &dulvl[prev_level].subdir); + duinfo_add (&dulvl[level].subdir, &dulvl[prev_level].ent); + duinfo_add (&dulvl[level].subdir, &dulvl[prev_level].subdir); + } + } + + prev_level = level; + + /* Let the size of a directory entry contribute to the total for the + containing directory, unless --separate-dirs (-S) is specified. */ + if (! (opt_separate_dirs && IS_DIR_TYPE (info))) + duinfo_add (&dulvl[level].ent, &dui); + + /* Even if this directory is unreadable or we can't chdir into it, + do let its size contribute to the total. */ + duinfo_add (&tot_dui, &dui); + + if ((IS_DIR_TYPE (info) && level <= max_depth) + || (opt_all && level <= max_depth) + || level == 0) + { + /* Print or elide this entry according to the --threshold option. */ + uintmax_t v = opt_inodes ? dui_to_print.inodes : dui_to_print.size; + if (opt_threshold < 0 + ? v <= -opt_threshold + : v >= opt_threshold) + print_size (&dui_to_print, file); + } + + return ok; +} + +/* Recursively print the sizes of the directories (and, if selected, files) + named in FILES, the last entry of which is NULL. + BIT_FLAGS controls how fts works. + Return true if successful. */ + +static bool +du_files (char **files, int bit_flags) +{ + bool ok = true; + + if (*files) + { + FTS *fts = xfts_open (files, bit_flags, NULL); + + while (1) + { + FTSENT *ent; + + ent = fts_read (fts); + if (ent == NULL) + { + if (errno != 0) + { + error (0, errno, _("fts_read failed: %s"), + quotef (fts->fts_path)); + ok = false; + } + + /* When exiting this loop early, be careful to reset the + global, prev_level, used in process_file. Otherwise, its + (level == prev_level - 1) assertion could fail. */ + prev_level = 0; + break; + } + FTS_CROSS_CHECK (fts); + + ok &= process_file (fts, ent); + } + + if (fts_close (fts) != 0) + { + error (0, errno, _("fts_close failed")); + ok = false; + } + } + + return ok; +} + +int +main (int argc, char **argv) +{ + char *cwd_only[2]; + bool max_depth_specified = false; + bool ok = true; + char *files_from = NULL; + + /* Bit flags that control how fts works. */ + int bit_flags = FTS_NOSTAT; + + /* Select one of the three FTS_ options that control if/when + to follow a symlink. */ + int symlink_deref_bits = FTS_PHYSICAL; + + /* If true, display only a total for each argument. */ + bool opt_summarize_only = false; + + cwd_only[0] = bad_cast ("."); + cwd_only[1] = NULL; + + initialize_main (&argc, &argv); + set_program_name (argv[0]); + setlocale (LC_ALL, ""); + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + + atexit (close_stdout); + + exclude = new_exclude (); + + human_options (getenv ("DU_BLOCK_SIZE"), + &human_output_opts, &output_block_size); + + while (true) + { + int oi = -1; + int c = getopt_long (argc, argv, "0abd:chHklmst:xB:DLPSX:", + long_options, &oi); + if (c == -1) + break; + + switch (c) + { +#if DU_DEBUG + case FTS_DEBUG: + fts_debug = true; + break; +#endif + + case '0': + opt_nul_terminate_output = true; + break; + + case 'a': + opt_all = true; + break; + + case APPARENT_SIZE_OPTION: + apparent_size = true; + break; + + case 'b': + apparent_size = true; + human_output_opts = 0; + output_block_size = 1; + break; + + case 'c': + print_grand_total = true; + break; + + case 'h': + human_output_opts = human_autoscale | human_SI | human_base_1024; + output_block_size = 1; + break; + + case HUMAN_SI_OPTION: + human_output_opts = human_autoscale | human_SI; + output_block_size = 1; + break; + + case 'k': + human_output_opts = 0; + output_block_size = 1024; + break; + + case 'd': /* --max-depth=N */ + { + unsigned long int tmp_ulong; + if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK + && tmp_ulong <= SIZE_MAX) + { + max_depth_specified = true; + max_depth = tmp_ulong; + } + else + { + error (0, 0, _("invalid maximum depth %s"), + quote (optarg)); + ok = false; + } + } + break; + + case 'm': + human_output_opts = 0; + output_block_size = 1024 * 1024; + break; + + case 'l': + opt_count_all = true; + break; + + case 's': + opt_summarize_only = true; + break; + + case 't': + { + enum strtol_error e; + e = xstrtoimax (optarg, NULL, 0, &opt_threshold, "kKmMGTPEZY0"); + if (e != LONGINT_OK) + xstrtol_fatal (e, oi, c, long_options, optarg); + if (opt_threshold == 0 && *optarg == '-') + { + /* Do not allow -0, as this wouldn't make sense anyway. */ + die (EXIT_FAILURE, 0, _("invalid --threshold argument '-0'")); + } + } + break; + + case 'x': + bit_flags |= FTS_XDEV; + break; + + case 'B': + { + enum strtol_error e = human_options (optarg, &human_output_opts, + &output_block_size); + if (e != LONGINT_OK) + xstrtol_fatal (e, oi, c, long_options, optarg); + } + break; + + case 'H': /* NOTE: before 2008-12, -H was equivalent to --si. */ + case 'D': + symlink_deref_bits = FTS_COMFOLLOW | FTS_PHYSICAL; + break; + + case 'L': /* --dereference */ + symlink_deref_bits = FTS_LOGICAL; + break; + + case 'P': /* --no-dereference */ + symlink_deref_bits = FTS_PHYSICAL; + break; + + case 'S': + opt_separate_dirs = true; + break; + + case 'X': + if (add_exclude_file (add_exclude, exclude, optarg, + EXCLUDE_WILDCARDS, '\n')) + { + error (0, errno, "%s", quotef (optarg)); + ok = false; + } + break; + + case FILES0_FROM_OPTION: + files_from = optarg; + break; + + case EXCLUDE_OPTION: + add_exclude (exclude, optarg, EXCLUDE_WILDCARDS); + break; + + case INODES_OPTION: + opt_inodes = true; + break; + + case TIME_OPTION: + opt_time = true; + time_type = + (optarg + ? XARGMATCH ("--time", optarg, time_args, time_types) + : time_mtime); + localtz = tzalloc (getenv ("TZ")); + break; + + case TIME_STYLE_OPTION: + time_style = optarg; + break; + + case_GETOPT_HELP_CHAR; + + case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); + + default: + ok = false; + } + } + + if (!ok) + usage (EXIT_FAILURE); + + if (opt_all && opt_summarize_only) + { + error (0, 0, _("cannot both summarize and show all entries")); + usage (EXIT_FAILURE); + } + + if (opt_summarize_only && max_depth_specified && max_depth == 0) + { + error (0, 0, + _("warning: summarizing is the same as using --max-depth=0")); + } + + if (opt_summarize_only && max_depth_specified && max_depth != 0) + { + unsigned long int d = max_depth; + error (0, 0, _("warning: summarizing conflicts with --max-depth=%lu"), d); + usage (EXIT_FAILURE); + } + + if (opt_summarize_only) + max_depth = 0; + + if (opt_inodes) + { + if (apparent_size) + { + error (0, 0, _("warning: options --apparent-size and -b are " + "ineffective with --inodes")); + } + output_block_size = 1; + } + + /* Process time style if printing last times. */ + if (opt_time) + { + if (! time_style) + { + time_style = getenv ("TIME_STYLE"); + + /* Ignore TIMESTYLE="locale", for compatibility with ls. */ + if (! time_style || STREQ (time_style, "locale")) + time_style = "long-iso"; + else if (*time_style == '+') + { + /* Ignore anything after a newline, for compatibility + with ls. */ + char *p = strchr (time_style, '\n'); + if (p) + *p = '\0'; + } + else + { + /* Ignore "posix-" prefix, for compatibility with ls. */ + static char const posix_prefix[] = "posix-"; + static const size_t prefix_len = sizeof posix_prefix - 1; + while (STREQ_LEN (time_style, posix_prefix, prefix_len)) + time_style += prefix_len; + } + } + + if (*time_style == '+') + time_format = time_style + 1; + else + { + switch (XARGMATCH ("time style", time_style, + time_style_args, time_style_types)) + { + case full_iso_time_style: + time_format = "%Y-%m-%d %H:%M:%S.%N %z"; + break; + + case long_iso_time_style: + time_format = "%Y-%m-%d %H:%M"; + break; + + case iso_time_style: + time_format = "%Y-%m-%d"; + break; + } + } + } + + struct argv_iterator *ai; + if (files_from) + { + /* When using --files0-from=F, you may not specify any files + on the command-line. */ + if (optind < argc) + { + error (0, 0, _("extra operand %s"), quote (argv[optind])); + fprintf (stderr, "%s\n", + _("file operands cannot be combined with --files0-from")); + usage (EXIT_FAILURE); + } + + if (! (STREQ (files_from, "-") || freopen (files_from, "r", stdin))) + die (EXIT_FAILURE, errno, _("cannot open %s for reading"), + quoteaf (files_from)); + + ai = argv_iter_init_stream (stdin); + + /* It's not easy here to count the arguments, so assume the + worst. */ + hash_all = true; + } + else + { + char **files = (optind < argc ? argv + optind : cwd_only); + ai = argv_iter_init_argv (files); + + /* Hash all dev,ino pairs if there are multiple arguments, or if + following non-command-line symlinks, because in either case a + file with just one hard link might be seen more than once. */ + hash_all = (optind + 1 < argc || symlink_deref_bits == FTS_LOGICAL); + } + + if (!ai) + xalloc_die (); + + /* Initialize the set of dev,inode pairs. */ + di_files = di_set_alloc (); + if (!di_files) + xalloc_die (); + + /* If not hashing everything, process_file won't find cycles on its + own, so ask fts_read to check for them accurately. */ + if (opt_count_all || ! hash_all) + bit_flags |= FTS_TIGHT_CYCLE_CHECK; + + bit_flags |= symlink_deref_bits; + static char *temp_argv[] = { NULL, NULL }; + + while (true) + { + bool skip_file = false; + enum argv_iter_err ai_err; + char *file_name = argv_iter (ai, &ai_err); + if (!file_name) + { + switch (ai_err) + { + case AI_ERR_EOF: + goto argv_iter_done; + case AI_ERR_READ: + error (0, errno, _("%s: read error"), + quotef (files_from)); + ok = false; + goto argv_iter_done; + case AI_ERR_MEM: + xalloc_die (); + default: + assert (!"unexpected error code from argv_iter"); + } + } + if (files_from && STREQ (files_from, "-") && STREQ (file_name, "-")) + { + /* Give a better diagnostic in an unusual case: + printf - | du --files0-from=- */ + error (0, 0, _("when reading file names from stdin, " + "no file name of %s allowed"), + quoteaf (file_name)); + skip_file = true; + } + + /* Report and skip any empty file names before invoking fts. + This works around a glitch in fts, which fails immediately + (without looking at the other file names) when given an empty + file name. */ + if (!file_name[0]) + { + /* Diagnose a zero-length file name. When it's one + among many, knowing the record number may help. + FIXME: currently print the record number only with + --files0-from=FILE. Maybe do it for argv, too? */ + if (files_from == NULL) + error (0, 0, "%s", _("invalid zero-length file name")); + else + { + /* Using the standard 'filename:line-number:' prefix here is + not totally appropriate, since NUL is the separator, not NL, + but it might be better than nothing. */ + unsigned long int file_number = argv_iter_n_args (ai); + error (0, 0, "%s:%lu: %s", quotef (files_from), + file_number, _("invalid zero-length file name")); + } + skip_file = true; + } + + if (skip_file) + ok = false; + else + { + temp_argv[0] = file_name; + ok &= du_files (temp_argv, bit_flags); + } + } + argv_iter_done: + + argv_iter_free (ai); + di_set_free (di_files); + if (di_mnt) + di_set_free (di_mnt); + + if (files_from && (ferror (stdin) || fclose (stdin) != 0) && ok) + die (EXIT_FAILURE, 0, _("error reading %s"), quoteaf (files_from)); + + if (print_grand_total) + print_size (&tot_dui, _("total")); + + return ok ? EXIT_SUCCESS : EXIT_FAILURE; +} + diff --git a/scripts/health/health.c b/scripts/health/health.c new file mode 100644 index 0000000..2c00478 --- /dev/null +++ b/scripts/health/health.c @@ -0,0 +1,220 @@ +#define DEBUG + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "health.h" +#include "utils.h" + +//ustring ok_str = NEW_USTRING("OK"); +//ustring warn_str = NEW_USTRING("WARN"); +//ustring arrow_str = NEW_USTRING("├─"); +//ustring arrow_last_str = NEW_USTRING("└─"); +ustring ok_str = {.str = "OK", .bytes = strlen("OK") }; +ustring warn_str = {.str = "WARN ☠", .bytes = strlen("WARN ☠")}; +ustring arrow_str = {.str = "├─", .bytes = strlen("├─")}; +ustring arrow_last_str = {.str ="└─", .bytes = strlen("└─")}; + +// fts_path doesn't append trailing slash +struct dir_status top_dir_var[] = { + WATCH_DIR("/var/cache", "1.5G"), + WATCH_DIR("/var/log", "0.5G") +}; + +struct dir_status top_dir_home[] = { + WATCH_DIR("/home/kuba/.cache", "3G"), + WATCH_DIR("/home/kuba/Downloads", "1G") +}; + +struct dir_status top_dir_usr[] = { + WATCH_DIR("/usr/local", "5G"), + WATCH_DIR("/usr/lib", "5G"), + WATCH_DIR("/usr/share", "5G"), + WATCH_DIR("/usr/bin", "1G") +}; + +struct dir_status watched_dirs[] = { + WATCH_DIR_SUBS("/var", "2.5G", top_dir_var), + WATCH_DIR_SUBS("/home/kuba", "20G", top_dir_home), + WATCH_DIR_SUBS("/usr", "15G", top_dir_usr), + WATCH_DIR("/boot", "80M"), + WATCH_DIR("/etc", "20M"), + WATCH_DIR("/root", "10M"), + WATCH_DIR("/run", "10M"), + WATCH_DIR("/srv", "1M"), + WATCH_DIR("/opt", "1G") +}; + +int main(int argc, char* const argv[]) +{ + INIT_USTRING(ok_str); + INIT_USTRING(warn_str); + INIT_USTRING(arrow_str); + INIT_USTRING(arrow_last_str); + // Traverse top directories and do some nice formatting + char buf[80]; + for (int i = 0; i < sizeof(watched_dirs)/sizeof(struct dir_status); i++){ + struct dir_status *dir = watched_dirs + i; + disk_usage(dir); + + format_directory_entry(buf, dir, 0, 0); + } + exit(0); + + if (argc<2) + { + printf("Usage: %s \n", argv[0]); + exit(255); + } + + return 0; +} + + +//Maybe just remove this, the effect is not noticable +off_t traverse_nochildren(FTS *file_system, const short dir_level) +{ + FTSENT *node = NULL; + struct stat *st = NULL; + off_t tot_size = 0; + + while( (node = fts_read(file_system)) != NULL) + { + // Add to size + st = node->fts_statp; + if (st) tot_size += (off_t) 512*st->st_blocks; + else debug("st null pointer, skipping\n"); + + if (node->fts_info == FTS_DP) + { + indent_debug(node->fts_level); + debug("Exiting %s\n", node->fts_path); + // Directory being visited in post-order. Only action is to + // return if back at the starting level + if (node->fts_level == dir_level) return tot_size; + } + } + return 0;// This is bad +} + +void traverse_children(FTS *file_system, struct dir_status *dir, const short dir_level) +{ + FTSENT *node = NULL; + struct stat *st = NULL; + off_t tot_size = 0; + + top_loop:while( (node = fts_read(file_system)) != NULL) + { + //indent_debug(node->fts_level); + //debug("%s\n", node->fts_name); + if (node->fts_info == FTS_D) + { + if(strcmp(node->fts_path, dir->path) == 0) { + continue; // Do nothing + } + indent_debug(node->fts_level); + debug("Entering %s\n", node->fts_path); + // Directory being visited in pre-order. Do not count size except + // after returning from a recursion step. Determine if the current + // node is one of the children. + for (int i = 0; i < dir->n_children; i++) { + struct dir_status *sub_dir = dir->children+i; + if(strcmp(node->fts_path, sub_dir->path) == 0){ + // Entering one of the child-directories + indent_debug(node->fts_level); + debug("Entering special %s\n", node->fts_path); + traverse_children(file_system, sub_dir, node->fts_level); + tot_size += sub_dir->size; + goto top_loop; + } + } + // Child directory not in list, call traverse_nochildren instead + tot_size += traverse_nochildren(file_system, node->fts_level); + continue; // Does the same as goto above + } + + // Add to size + st = node->fts_statp; + if (st) tot_size += (off_t) 512*st->st_blocks; + else debug("st null pointer, skipping\n"); + + if (node->fts_info == FTS_DP) + { + indent_debug(node->fts_level); + debug("Exiting %s\n", node->fts_path); + // Directory being visited in post-order. Only action is to save + // size and return if back at the starting level + if (node->fts_level == dir_level){ + dir->size = tot_size; + return; + } + } + } +} + +int disk_usage(struct dir_status *top_dir) +{ + char *paths[] = { top_dir->path, NULL}; + FTS* file_system = NULL; + + file_system = fts_open(paths, FTS_PHYSICAL, NULL); + + if (file_system == NULL) return 1; + + traverse_children(file_system, top_dir, 0); + + fts_close(file_system); + return 0; +} + +const int max_length = 60; +const int max_path_length = 40; +void format_directory_entry(char *buf, struct dir_status *dir, int level, int last_subdir) +{ + int n = 0; //Keeps track of where in buffer we are + int delta_n = 0; // Keeps track of how much shorter the string appears + // than the number of bytes + + // First fill with apropriate amount of spaces and └ or ├ charcters + if (level > 0) { + ustring *arr = last_subdir?&arrow_last_str:&arrow_str; + + n = 4*level - arr->chars; + delta_n += arr->chars - arr->bytes; + memset(buf, ' ', n); + strncpy(buf+n, arr->str, arr->bytes); + n += arr->bytes; + } + + // Path and size + n += snprintf(buf + n, max_path_length, "%s -- ", dir->path); + n += pretty_bytes(buf + n, dir->size); + memset(buf + n, ' ', max_length - n); // max_length - n for simplicity + + // Right-justify WARN or OK status + ustring *ok = directory_ok(dir->size, dir->warn_at)?&ok_str:&warn_str; + delta_n += ok->chars - ok->bytes; + snprintf(buf + max_length - ok->bytes - 2 - delta_n, ok->bytes+2 + , "%s\n", ok->str);// 2 leaves space for \n and null + printf("%s", buf); + + // Loop through children + for (int i = 0; i < dir->n_children; i++){ + int last = (i == dir->n_children - 1); + format_directory_entry(buf, dir->children + i, (level + 1), last); + } + + if(level == 0) printf("\n"); +} +int directory_ok(off_t size, char *warn_at){ + off_t warn = pretty_bytes_to_num(warn_at); + return size < warn; +} + diff --git a/scripts/health/health.h b/scripts/health/health.h new file mode 100644 index 0000000..ca0a198 --- /dev/null +++ b/scripts/health/health.h @@ -0,0 +1,43 @@ +#ifndef HEALTH_H +#define HEALTH_H + +#include +#include "utils.h" + +/* + * path - Path of the directory without trailing slash + * warn_at - How large is the directory allowed to be before a warning is + * issued. In human readable form (see utils.c:pretty_bytes) + * children - List of all watched sub-directories + * n_children - Number of elements in children + * size - Size of directory, this is filled in by disk_usage() + */ +struct dir_status { + char * const path; + char * const warn_at; + struct dir_status *children; + int n_children; + off_t size; +}; + +#define WATCH_DIR(pth,wrn) {.path = pth, .warn_at = wrn, .n_children=0, .size=0} +#define WATCH_DIR_SUBS(pth,wrn,subs) {.path = pth, .warn_at = wrn, .size=0 \ + , .children=subs, .n_children=sizeof(subs)/sizeof(struct dir_status)} + +off_t traverse_nochildren(FTS *file_system, const short dir_level); +void traverse_children(FTS *file_system, struct dir_status *dir, const short dir_level); +int disk_usage(struct dir_status *top_dir); + +//ustring ok_ustr = {.str = "OK", .bytes = 2, .chars = 2}; +//NEW_USTRING(ok_str, "OK"); +//NEW_USTRING(warn_str, "WARN"); +//NEW_USTRING(arrow_str, "├─"); +//NEW_USTRING(arrow_last_str,"└─"); +//INIT_USTRING(ok_str); +//INIT_USTRING(warn_str); +//INIT_USTRING(arrow_str); +//INIT_USTRING(arrow_last_str); +void format_directory_entry(char *buf, struct dir_status *dir, int level, int last_subdir); +int directory_ok(off_t size, char *warn_at); + +#endif diff --git a/scripts/health/makefile b/scripts/health/makefile new file mode 100755 index 0000000..b25e3e4 --- /dev/null +++ b/scripts/health/makefile @@ -0,0 +1,24 @@ +CFLAGS = -Wall +LDFLAGS = -lm +CC = gcc + +default: health + +optim: CFLAGS += -O3 +optim: health + +debug: CFLAGS += -g +debug: health + +OBJECTS=health.o utils.o +health: $(OBJECTS) + $(CC) $(CFLAGS) -o health $(OBJECTS) $(LDFLAGS) + +health.o: health.c health.h + $(CC) $(CFLAGS) -c health.c + +utils.o: utils.c utils.h + $(CC) $(CFLAGS) -c utils.c + +clean: + rm -f *.o diff --git a/scripts/health/utils.c b/scripts/health/utils.c new file mode 100644 index 0000000..fc4d9d8 --- /dev/null +++ b/scripts/health/utils.c @@ -0,0 +1,87 @@ +#include +#include +#include +#include + +#include "utils.h" + + +void indent(int i) +{ + for (; i > 0; i--) printf(" "); +} + + +// Prints to the provided buffer a nice number of bytes (KB, MB, GB, etc) +// Returns bytes written +int pretty_bytes(char* buf, long long bytes) +{ + const char* suffixes[7]; + suffixes[0] = "B"; + suffixes[1] = "KB"; + suffixes[2] = "MB"; + suffixes[3] = "GB"; + suffixes[4] = "TB"; + suffixes[5] = "PB"; + suffixes[6] = "EB"; + uint s = 0; // which suffix to use + double count = bytes; + while (count >= 1024 && s < 7) + { + s++; + count /= 1024; + } + if (count - floor(count) == 0.0) + return sprintf(buf, "%d %s", (int)count, suffixes[s]); + else + return sprintf(buf, "%.1f %s", count, suffixes[s]); +} + +long long pretty_bytes_to_num(char* buf) +{ + // First letter of suffix in order + const char suffixes[7] = {'B', 'K', 'M', 'G', 'T', 'P', 'E'}; + char suffix; + float fnum; + long long num = 1; + int n; + + errno = 0; + n = sscanf(buf,"%f%c", &fnum, &suffix); + if (n == 2) { + //TODO error handling + } else if (errno != 0) { + perror("scanf"); + } else { + fprintf(stderr, "No matching characters\n"); + } + + for (int s=0;s +#include + +size_t utf8len(const char *s); + +typedef struct { + const char *str; + const size_t bytes; + size_t chars; +} ustring; + + +#define NEW_USTRING(string) {.str = string, .bytes = strlen(string)}//; varname.chars=utf8len(string)} +#define INIT_USTRING(varname) (varname).chars = utf8len(varname.str) + +long long pretty_bytes_to_num(char* buf); +int pretty_bytes(char* buf, long long bytes); +void debug(const char *format, ...); +void indent (int i); +void indent_debug (int i); + +#endif diff --git a/scripts/set_bg.sh b/scripts/set_bg.sh new file mode 100755 index 0000000..e469a9b --- /dev/null +++ b/scripts/set_bg.sh @@ -0,0 +1,24 @@ +#!/bin/bash +#function get_index(){ +# for i in "${!xra_out[@]}"; do +# if [[ "${xra_out[$i]}" = "$value" ]]; then +# echo "${i}"; +# break +# fi +# done +#} +#xra_out=($(xrandr | grep ' connected' | awk '{print $1}')) +#in=($@) +#for i in `seq 0 2 ${#in[@]}`; do +# value="${in[$i]}" +# idx=$(get_index) +# if [ ! -z "$idx" ]; then +# screen_idx="$idx" +# #"${xra_out[$idx-1]}" +# paths[${screen_idx%:}]="--bg-scale ${in[$i+1]}" +# fi +#done +##echo "${paths[@]}" +#str=`printf -v var "%s\n" "${System[@]}"` +#sh -c "feh ${paths[@]}" +feh --bg-scale "$@"