Dynamically scale the ST_UID size to support 32-bit UIDs

While most Unix-like systems use 16-bit user IDs,
Linux supports 32-bit UIDs since version 2.6.
UIDs above 65535 are used for UID namespacing of containers,
where a container has its own set of 16-bit user IDs.
Processes in such containers will have (much) larger UIDs than 65535.

Because the current format strings for `ST_UID` and `USER`
are `%5d` and `%9d` respectively, processes with such UIDs
lead to misaligned columns.

Dynamically scale the `ST_UID` column and increase the size of `USER`
to 10 characters (length of UINT32_MAX) to ensure that the user ID always fits.

Additionally: clean up how the titlebuffer size calculation and ensure
the PID column has a minimum size of 5.

Process.c

@@ -41,17 +41,33 @@ static const char* const kthreadID = "KTHREAD";
 
 static uid_t Process_getuid = (uid_t)-1;
 
-int Process_pidDigits = 7;
+int Process_pidDigits = PROCESS_MIN_PID_DIGITS;
+int Process_uidDigits = PROCESS_MIN_UID_DIGITS;
 
 void Process_setupColumnWidths() {
    int maxPid = Platform_getMaxPid();
    if (maxPid == -1)
       return;
 
+   if (maxPid < (int)pow(10, PROCESS_MIN_PID_DIGITS)) {
+      Process_pidDigits = PROCESS_MIN_PID_DIGITS;
+      return;
+   }
+
    Process_pidDigits = ceil(log10(maxPid));
    assert(Process_pidDigits <= PROCESS_MAX_PID_DIGITS);
 }
 
+void Process_setUidColumnWidth(uid_t maxUid) {
+   if (maxUid < (uid_t)pow(10, PROCESS_MIN_UID_DIGITS)) {
+      Process_uidDigits = PROCESS_MIN_UID_DIGITS;
+      return;
+   }
+
+   Process_uidDigits = ceil(log10(maxUid));
+   assert(Process_uidDigits <= PROCESS_MAX_UID_DIGITS);
+}
+
 void Process_printBytes(RichString* str, unsigned long long number, bool coloring) {
    char buffer[16];
    int len;
@@ -885,7 +901,7 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
             break;
       }
       break;
-   case ST_UID: xSnprintf(buffer, n, "%5d ", this->st_uid); break;
+   case ST_UID: xSnprintf(buffer, n, "%*d ", Process_uidDigits, this->st_uid); break;
    case TIME: Process_printTime(str, this->time, coloring); return;
    case TGID:
       if (this->tgid == this->pid)
@@ -908,11 +924,11 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
          attr = CRT_colors[PROCESS_SHADOW];
 
       if (this->user) {
-         Process_printLeftAlignedField(str, attr, this->user, 9);
+         Process_printLeftAlignedField(str, attr, this->user, 10);
          return;
       }
 
-      xSnprintf(buffer, n, "%-9d ", this->st_uid);
+      xSnprintf(buffer, n, "%-10d ", this->st_uid);
       break;
    default:
       if (DynamicColumn_writeField(this, str, field))

Process.h

@@ -278,8 +278,12 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
 int Process_compare(const void* v1, const void* v2);
 void Process_delete(Object* cast);
 extern const ProcessFieldData Process_fields[LAST_PROCESSFIELD];
+#define PROCESS_MIN_PID_DIGITS 5
 #define PROCESS_MAX_PID_DIGITS 19
+#define PROCESS_MIN_UID_DIGITS 5
+#define PROCESS_MAX_UID_DIGITS 19
 extern int Process_pidDigits;
+extern int Process_uidDigits;
 
 typedef Process* (*Process_New)(const struct Settings_*);
 typedef void (*Process_WriteField)(const Process*, RichString*, ProcessField);
@@ -337,6 +341,9 @@ static inline bool Process_isThread(const Process* this) {
 
 void Process_setupColumnWidths(void);
 
+/* Sets the size of the UID column based on the passed UID */
+void Process_setUidColumnWidth(uid_t maxUid);
+
 /* Takes number in bytes (base 1024). Prints 6 columns. */
 void Process_printBytes(RichString* str, unsigned long long number, bool coloring);
 

ProcessList.c

@@ -105,15 +105,21 @@ static const char* alignedProcessFieldTitle(const ProcessList* this, ProcessFiel
    if (!title)
       return "- ";
 
-   if (!Process_fields[field].pidColumn)
+   if (Process_fields[field].pidColumn) {
-      return title;
+      static char titleBuffer[PROCESS_MAX_PID_DIGITS + sizeof(" ")];
-
-   static char titleBuffer[PROCESS_MAX_PID_DIGITS + /* space */ 1 + /* null-terminator */ + 1];
       xSnprintf(titleBuffer, sizeof(titleBuffer), "%*s ", Process_pidDigits, title);
-
       return titleBuffer;
    }
 
+   if (field == ST_UID) {
+      static char titleBuffer[PROCESS_MAX_UID_DIGITS + sizeof(" ")];
+      xSnprintf(titleBuffer, sizeof(titleBuffer), "%*s ", Process_uidDigits, title);
+      return titleBuffer;
+   }
+
+   return title;
+}
+
 void ProcessList_printHeader(const ProcessList* this, RichString* header) {
    RichString_rewind(header, RichString_size(header));
 
@@ -626,10 +632,15 @@ void ProcessList_scan(ProcessList* this, bool pauseProcessUpdate) {
 
    ProcessList_goThroughEntries(this, false);
 
+   uid_t maxUid = 0;
    for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
       Process* p = (Process*) Vector_get(this->processes, i);
       Process_makeCommandStr(p);
 
+      // keep track of the highest UID for column scaling
+      if (p->st_uid > maxUid)
+         maxUid = p->st_uid;
+
       if (p->tombStampMs > 0) {
          // remove tombed process
          if (this->monotonicMs >= p->tombStampMs) {
@@ -647,6 +658,9 @@ void ProcessList_scan(ProcessList* this, bool pauseProcessUpdate) {
       }
    }
 
+   // Set UID column width based on max UID.
+   Process_setUidColumnWidth(maxUid);
+
    if (this->settings->treeView) {
       // Clear out the hashtable to avoid any left-over processes from previous build
       //

ScreenManager.c

@@ -88,7 +88,7 @@ void ScreenManager_resize(ScreenManager* this) {
    Panel_move(panel, lastX, y1_header);
 }
 
-static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTimeout, bool* redraw, bool* rescan, bool* timedOut) {
+static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTimeout, bool* redraw, bool* rescan, bool* timedOut, bool *force_redraw) {
    ProcessList* pl = this->header->pl;
 
    Platform_gettime_realtime(&pl->realtime, &pl->realtimeMs);
@@ -103,6 +103,7 @@ static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTi
 
    if (*rescan) {
       *oldTime = newTime;
+      int oldUidDigits = Process_uidDigits;
       // scan processes first - some header values are calculated there
       ProcessList_scan(pl, this->state->pauseProcessUpdate);
       // always update header, especially to avoid gaps in graph meters
@@ -111,6 +112,10 @@ static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTi
          ProcessList_sort(pl);
          *sortTimeout = 1;
       }
+      // force redraw if the number of UID digits was changed
+      if (Process_uidDigits != oldUidDigits) {
+         *force_redraw = true;
+      }
       *redraw = true;
    }
    if (*redraw) {
@@ -153,7 +158,7 @@ void ScreenManager_run(ScreenManager* this, Panel** lastFocus, int* lastKey) {
 
    while (!quit) {
       if (this->header) {
-         checkRecalculation(this, &oldTime, &sortTimeout, &redraw, &rescan, &timedOut);
+         checkRecalculation(this, &oldTime, &sortTimeout, &redraw, &rescan, &timedOut, &force_redraw);
       }
 
       if (redraw || force_redraw) {