Clean up path processing

lib/cfg.c

@@ -87,8 +87,8 @@ void rm_cfg_set_default(RmCfg *cfg) {
      * 32k => 15.8 seconds */
     cfg->read_buf_len = 16 * 1024;
 
-    cfg->total_mem = (RmOff)1024 * 1024 * 1024;
-    cfg->sweep_size = 1024 * 1024 * 1024;
+    cfg->total_mem = 1024L * 1024 * 1024;
+    cfg->sweep_size = 1024L * 1024 * 1024;
     cfg->sweep_count = 1024 * 16;
 
     cfg->skip_start_factor = 0.0;

lib/formats/progressbar.c

@@ -132,7 +132,7 @@ static char *rm_fmt_progress_get_cached_eta(
 
     gint64 now = g_get_real_time();
     if(self->last_eta[0] != 0) {
-        if(ABS(now - self->last_eta_update) <= 500 * 1000) {
+        if(ABS(now - self->last_eta_update) <= 500L * 1000) {
             return self->last_eta;
         }
     }

lib/hash-utility.c

@@ -119,7 +119,7 @@ int rm_hasher_main(int argc, const char **argv) {
     /* Digest type */
     tag.digest_type = RM_DEFAULT_DIGEST;
     gint threads = 8;
-    gint64 buffer_mbytes = 256;
+    guint64 buffer_mbytes = 256;
     guint64 increment = 4096;
 
     ////////////// Option Parsing ///////////////
@@ -213,7 +213,7 @@ int rm_hasher_main(int argc, const char **argv) {
                                      threads,
                                      FALSE,
                                      increment,
-                                     1024 * 1024 * buffer_mbytes,
+                                     1024L * 1024 * buffer_mbytes,
                                      (RmHasherCallback)rm_hasher_callback,
                                      &tag);
 

lib/md-scheduler.c

@@ -30,9 +30,9 @@
  * debug messages by continually recycling back to the joiner.
  */
 #if _RM_MDS_DEBUG
-#define MDS_EMPTYQUEUE_SLEEP_US (60 * 1000 * 1000) /* 60 seconds */
+#define MDS_EMPTYQUEUE_SLEEP_US (60L * 1000 * 1000) /* 60 seconds */
 #else
-#define MDS_EMPTYQUEUE_SLEEP_US (50 * 1000) /* 0.05 second */
+#define MDS_EMPTYQUEUE_SLEEP_US (50L * 1000) /* 0.05 second */
 #endif
 
 ///////////////////////////////////////

lib/session.c

@@ -230,7 +230,7 @@ int rm_session_dedupe_main(RmCfg *cfg) {
 /* clang-format on */
 
     /* a poorly-documented limit for dedupe ioctl's */
-    static const gint64 max_dedupe_chunk = 16 * 1024 * 1024;
+    static const gint64 max_dedupe_chunk = 16L * 1024 * 1024;
 
     /* how fine a resolution to use once difference detected;
      * use btrfs default node size (16k): */

lib/shredder.c

@@ -275,14 +275,14 @@
 #define SHRED_PAGE_SIZE (sysconf(_SC_PAGESIZE))
 
 #define SHRED_MAX_READ_FACTOR \
-    ((256 * 1024 * 1024) / SHRED_BALANCED_PAGES / SHRED_PAGE_SIZE)
+    ((256L * 1024 * 1024) / SHRED_BALANCED_PAGES / SHRED_PAGE_SIZE)
 
 /* Maximum increment size for paranoid digests.  This is smaller than for other
  * digest types due to memory management issues.
  * 16MB should be big enough buffer size to make seek time fairly insignificant
  * relative to sequential read time, eg 16MB read at typical 100 MB/s read
  * rate = 160ms read vs typical seek time 10ms*/
-#define SHRED_PARANOID_BYTES (16 * 1024 * 1024)
+#define SHRED_PARANOID_BYTES (16L * 1024 * 1024)
 
 /* When paranoid hashing, if a file increments is larger
  * than SHRED_PREMATCH_THRESHOLD, we take a guess at the likely
@@ -296,7 +296,7 @@
 #define SHRED_AVERAGE_MEM_PER_FILE (100)
 
 /* Maximum number of bytes before worth_waiting becomes false */
-#define SHRED_TOO_MANY_BYTES_TO_WAIT (64 * 1024 * 1024)
+#define SHRED_TOO_MANY_BYTES_TO_WAIT (64L * 1024 * 1024)
 
 ///////////////////////////////////////////////////////////////////////
 //    INTERNAL STRUCTURES, WITH THEIR INITIALISERS AND DESTROYERS    //
@@ -1742,7 +1742,7 @@ void rm_shred_run(RmSession *session) {
     /* estimate mem used for RmFiles and allocate any leftovers to read buffer and/or
      * paranoid mem */
     RmOff mem_used = SHRED_AVERAGE_MEM_PER_FILE * session->shred_files_remaining;
-    RmOff read_buffer_mem = MAX(1024 * 1024, (gint64)cfg->total_mem - (gint64)mem_used);
+    RmOff read_buffer_mem = MAX(1024L * 1024, cfg->total_mem - mem_used);
 
     if(cfg->checksum_type == RM_DIGEST_PARANOID) {
         /* allocate any spare mem for paranoid hashing */

lib/utilities.c

@@ -374,9 +374,9 @@ char *rm_util_get_groupname(void) {
 void rm_util_size_to_human_readable(RmOff num, char *in, gsize len) {
     if(num < 512) {
         snprintf(in, len, "%" LLU " B", num);
-    } else if(num < 512 * 1024) {
+    } else if(num < 512L * 1024) {
         snprintf(in, len, "%.2f KB", num / 1024.0);
-    } else if(num < 512 * 1024 * 1024) {
+    } else if(num < 512L * 1024 * 1024) {
         snprintf(in, len, "%.2f MB", num / (1024.0 * 1024.0));
     } else {
         snprintf(in, len, "%.2f GB", num / (1024.0 * 1024.0 * 1024.0));
@@ -1342,7 +1342,7 @@ bool rm_iso8601_format(time_t stamp, char *buf, gsize buf_size) {
     return false;
 }
 
-#define SECONDS_PER_DAY (24 * 60 * 60)
+#define SECONDS_PER_DAY (24L * 60 * 60)
 #define SECONDS_PER_HOUR (60 * 60)
 #define SECONDS_PER_MINUTE (60)