Merge pull request #81 from kakra/io-priorities

Adjust IO priorities of clients

daemon/daemon_config.c

@@ -70,6 +70,8 @@ struct GameModeConfig {
 	char softrealtime[CONFIG_VALUE_MAX];
 	long renice;
 
+	char ioprio[CONFIG_VALUE_MAX];
+
 	long reaper_frequency;
 };
 
@@ -164,6 +166,8 @@ static int inih_handler(void *user, const char *section, const char *name, const
 			valid = get_string_value(value, self->softrealtime);
 		} else if (strcmp(name, "renice") == 0) {
 			valid = get_long_value(name, value, &self->renice);
+		} else if (strcmp(name, "ioprio") == 0) {
+			valid = get_string_value(value, self->ioprio);
 		}
 	} else if (strcmp(section, "custom") == 0) {
 		/* Custom subsection */
@@ -215,6 +219,7 @@ static void load_config_files(GameModeConfig *self)
 	pthread_rwlock_wrlock(&self->rwlock);
 
 	/* Clear our config values */
+	memset(self->ioprio, 0, sizeof(self->ioprio));
 	memset(self->whitelist, 0, sizeof(self->whitelist));
 	memset(self->blacklist, 0, sizeof(self->blacklist));
 	memset(self->startscripts, 0, sizeof(self->startscripts));
@@ -426,3 +431,18 @@ void config_get_renice_value(GameModeConfig *self, long *value)
 {
 	memcpy_locked_config(self, value, &self->renice, sizeof(long));
 }
+
+/*
+ * Get the ioprio value
+ */
+void config_get_ioprio_value(GameModeConfig *self, int *value)
+{
+	char ioprio_value[CONFIG_VALUE_MAX] = { 0 };
+	memcpy_locked_config(self, ioprio_value, &self->ioprio, sizeof(self->ioprio));
+	if (0 == strncmp(ioprio_value, "off", sizeof(self->ioprio)))
+		*value = IOPRIO_DONT_SET;
+	else if (0 == strncmp(ioprio_value, "default", sizeof(self->ioprio)))
+		*value = IOPRIO_RESET_DEFAULT;
+	else
+		*value = atoi(ioprio_value);
+}

daemon/daemon_config.h

@@ -39,6 +39,12 @@ POSSIBILITY OF SUCH DAMAGE.
 #define CONFIG_LIST_MAX 32
 #define CONFIG_VALUE_MAX 256
 
+/*
+ * Special ioprio values
+ */
+#define IOPRIO_RESET_DEFAULT -1
+#define IOPRIO_DONT_SET -2
+
 /*
  * Opaque config context type
  */
@@ -113,3 +119,8 @@ void config_get_soft_realtime(GameModeConfig *self, char softrealtime[CONFIG_VAL
  * Get the renice value
  */
 void config_get_renice_value(GameModeConfig *self, long *value);
+
+/*
+ * Get the ioprio value
+ */
+void config_get_ioprio_value(GameModeConfig *self, int *value);

daemon/gamemode.c

@@ -35,6 +35,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "daemon_config.h"
 #include "governors-query.h"
 #include "governors.h"
+#include "ioprio.h"
 #include "logging.h"
 
 #include <linux/limits.h>
@@ -44,6 +45,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <signal.h>
 #include <stdatomic.h>
 #include <string.h>
+#include <sys/param.h>
 #include <sys/resource.h>
 #include <sys/sysinfo.h>
 #include <systemd/sd-daemon.h>
@@ -59,6 +61,10 @@ POSSIBILITY OF SUCH DAMAGE.
  */
 #define NICE_DEFAULT_PRIORITY -4
 
+/* Value clamping helper.
+ */
+#define CLAMP(lbound, ubound, value) MIN(MIN(lbound, ubound), MAX(MAX(lbound, ubound), value))
+
 /**
  * The GameModeClient encapsulates the remote connection, providing a list
  * form to contain the pid and credentials.
@@ -236,6 +242,56 @@ static void game_mode_apply_scheduler(GameModeContext *self, pid_t client)
 	}
 }
 
+/**
+ * Apply io priorities
+ *
+ * This tries to change the io priority of the client to a value specified
+ * and can possibly reduce lags or latency when a game has to load assets
+ * on demand.
+ */
+static void game_mode_apply_ioprio(GameModeContext *self, pid_t client)
+{
+	LOG_MSG("Setting scheduling policies...\n");
+
+	/*
+	 * read configuration "ioprio" (0..7)
+	 */
+	int ioprio = 0;
+	config_get_ioprio_value(self->config, &ioprio);
+	if (IOPRIO_RESET_DEFAULT == ioprio) {
+		LOG_MSG("IO priority will be reset to default behavior (based on CPU priority).\n");
+		ioprio = 0;
+	} else if (IOPRIO_DONT_SET == ioprio) {
+		return;
+	} else {
+		/* maybe clamp the value */
+		int invalid_ioprio = ioprio;
+		ioprio = CLAMP(0, 7, ioprio);
+		if (ioprio != invalid_ioprio)
+			LOG_ERROR("IO priority value %d invalid, clamping to %d\n", invalid_ioprio, ioprio);
+
+		/* We support only IOPRIO_CLASS_BE as IOPRIO_CLASS_RT required CAP_SYS_ADMIN */
+		ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, ioprio);
+	}
+
+	/*
+	 * Actually apply the io priority
+	 */
+	int c = IOPRIO_PRIO_CLASS(ioprio), p = IOPRIO_PRIO_DATA(ioprio);
+	if (ioprio_set(IOPRIO_WHO_PROCESS, client, ioprio) == 0) {
+		if (0 == ioprio)
+			LOG_MSG("Resetting client [%d] IO priority.\n", client);
+		else
+			LOG_MSG("Setting client [%d] IO priority to (%d,%d).\n", client, c, p);
+	} else {
+		LOG_ERROR("Setting client [%d] IO priority to (%d,%d) failed with error %d, ignoring\n",
+		          client,
+		          c,
+		          p,
+		          errno);
+	}
+}
+
 /**
  * Pivot into game mode.
  *
@@ -432,6 +488,9 @@ bool game_mode_context_register(GameModeContext *self, pid_t client)
 	/* Apply scheduler policies */
 	game_mode_apply_scheduler(self, client);
 
+	/* Apply io priorities */
+	game_mode_apply_ioprio(self, client);
+
 	return true;
 error_cleanup:
 	game_mode_client_free(cl);

daemon/ioprio.h

@@ -0,0 +1,82 @@
+/*
+
+Copyright (c) 2017-2018, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+#pragma once
+
+#define _GNU_SOURCE
+#include <sys/syscall.h>
+#include <unistd.h>
+
+/**
+ * Define the syscall interface in Linux because it is missing from glibc
+ */
+
+#ifndef IOPRIO_BITS
+#define IOPRIO_BITS (16)
+#endif
+
+#ifndef IOPRIO_CLASS_SHIFT
+#define IOPRIO_CLASS_SHIFT (13)
+#endif
+
+#ifndef IOPRIO_PRIO_MASK
+#define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1)
+#endif
+
+#ifndef IOPRIO_PRIO_CLASS
+#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
+#endif
+
+#ifndef IOPRIO_PRIO_DATA
+#define IOPRIO_PRIO_DATA(mask) ((mask)&IOPRIO_PRIO_MASK)
+#endif
+
+#ifndef IOPRIO_PRIO_VALUE
+#define IOPRIO_PRIO_VALUE(class, data) (((class) << IOPRIO_CLASS_SHIFT) | data)
+#endif
+
+enum {
+	IOPRIO_CLASS_NONE,
+	IOPRIO_CLASS_RT,
+	IOPRIO_CLASS_BE,
+	IOPRIO_CLASS_IDLE,
+};
+
+enum {
+	IOPRIO_WHO_PROCESS = 1,
+	IOPRIO_WHO_PGRP,
+	IOPRIO_WHO_USER,
+};
+
+static inline int ioprio_set(int which, int who, int ioprio)
+{
+	return (int)syscall(SYS_ioprio_set, which, who, ioprio);
+}