I also wonder if i should add functionality for setting scheduling and i/o priorities while at it, and perhaps oom-killer score adjustment (they are useful to have especially for services that change uid, as any wrapper will already run with decreased privileges)? i could also do it later, but it's simple enough to do...

i guess all 3 of these should also be specific to linux at this point, because the implementation will differ and so will the range? should these also be behind an option like cgroups? or just #ifdef __linux__?

this is what the setting of the 3 values would look like without the parsing (the input values for nice would go integer -20 to 19, for ionice it would probably be good to parse it properly which would mean none, rt:0 to rt:7, be:0 to be:7 and idle, for oom adjustment it should take -1000 to 1000), and guards:

diff --git a/src/includes/proc-service.h b/src/includes/proc-service.h
index bb7ed42..8d622cd 100644
--- a/src/includes/proc-service.h
+++ b/src/includes/proc-service.h
@@ -43,6 +43,9 @@ struct run_proc_params
     bool on_console;          // whether to run on console
     bool in_foreground;       // if on console: whether to run in foreground
     bool unmask_sigint = false; // if in foreground: whether to unmask SIGINT
+    int nice = INT_MIN;
+    int ionice = INT_MIN;
+    int oom_adj = INT_MIN;
     int wpipefd;              // pipe to which error status will be sent (if error occurs)
     int csfd;                 // control socket fd (or -1); may be moved
     int socket_fd;            // pre-opened socket fd (or -1); may be moved
diff --git a/src/run-child-proc.cc b/src/run-child-proc.cc
index b206b6d..ef9392b 100644
--- a/src/run-child-proc.cc
+++ b/src/run-child-proc.cc
@@ -65,6 +65,9 @@ void base_process_service::run_child_proc(run_proc_params params) noexcept
     const char *working_dir = params.working_dir;
     const char *logfile = params.logfile;
     bool on_console = params.on_console;
+    int nice = params.nice;
+    int ionice = params.ionice;
+    int oom_adj = params.oom_adj;
     int wpipefd = params.wpipefd;
     int csfd = params.csfd;
     int notify_fd = params.notify_fd;
@@ -301,6 +304,38 @@ void base_process_service::run_child_proc(run_proc_params params) noexcept
         if (setrlimit(limit.resource_id, &setlimits) != 0) goto failure_out;
     }
 
+    // nice
+    if (nice != INT_MIN) {
+        if (setpriority(PRIO_PROCESS, getpid(), nice) != 0) goto failure_out;
+        // we usually create a new session leader; that makes nice not very
+        // useful as the Linux kernel will autogroup processes by session id
+        // except when disabled - so also work around this where enabled
+        // the r+ is used in order to avoid creating it where already disabled
+        errno = 0;
+        FILE *ag = std::fopen("/proc/self/autogroup", "r+");
+        if (ag) {
+            std::fprintf(ag, "%d\n", nice);
+            std::fclose(ag);
+        }
+        else if (errno != ENOENT) goto failure_out;
+    }
+
+    // ionice
+    if (ionice != INT_MIN) {
+        #ifdef __NR_ioprio_set
+        if (syscall(__NR_ioprio_set, 1, (int)getpid(), ionice) != 0) goto failure_out;
+        #endif
+    }
+
+    // oom score adjustment
+    if (oom_adj != INT_MIN) {
+        errno = 0;
+        FILE *adj = std::fopen("/proc/self/oom_score_adj", "w");
+        if (!adj) goto failure_out;
+        std::fprintf(adj, "%d\n", oom_adj);
+        std::fclose(adj);
+    }
+
     #if SUPPORT_CGROUPS
     if (params.run_in_cgroup != nullptr && *params.run_in_cgroup != 0) {
         err.stage = exec_stage::ENTER_CGROUP;

I implemented everything. What's left now is basically

1. documentation
2. testing
3. deciding how to guard the features; whether we should have a separate feature for each mainly
4. the cap parsing thing
5. maybe something else? you tell me

No strong objections/opinions from me, though as usual good documentation will be important.

nice/io_nice/oom_adj are probably unnecessary when cgroups are used properly. If they were to be supported, documentation must clearly state the requirements, i.e. /proc must be mounted for oom_adj.

One thing I am not sure about for example is the IAB string parsing; I currently do it in load-service.cc

I think that's fine tbh.

It might be worth gating Linux-specific features behind something other than __linux__, so you can use it in documentation too (and so those that prefer to use cgroups could just disable these features).

Setting for nice should be possible on other OSes, setpriority and nice are both part of POSIX (and I think you can use nice rather than setpriority unless I've missed something). The autogroups hack is unfortunate, I guess there's no way around it though.

well, nice will add to the current level, while setpriority actually sets it, so there is a difference - both are posix though...

the main non-portability for that is range checking, as the acceptable range of values may vary depending on systems

maybe i could

1. implement nice unconditionally - not sure about the range checking part though? setpriority will clamp the input, so if you set it too high or too low, it will use the nearest supported value; but either way, do the autogroups hack only for linux
2. put the ionice behind its own feature
3. put the oom-score-adj behind its own feature

well, nice will add to the current level, while setpriority actually sets it, so there is a difference

Ah right, yeah.

the main non-portability for that is range checking, as the acceptable range of values may vary depending on systems

True, but I don't think we need to be overly fussed about checking it ourselves. Perhaps add a flag to indicate whether the value is set rather than relying on INT_MIN as a sentinel value.

maybe i could [...]

Yep, that sounds reasonable to me.

ok, i think i should have a cleaned up PR sometime this evening...

I added documentation, feature flags, and improved the resource management for the capabilities IAB object, which should be a lot cleaner now.

It should be reviewable now, though I still need to test it a bunch more.

Will review this weekend