kernel-features.c

/*
 * libhugetlbfs - Easy use of Linux hugepages
 * Copyright (C) 2008 Adam Litke, IBM Corporation.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#define _GNU_SOURCE 		/* For strchrnul */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/utsname.h>
#include "kernel-features.h"
#include "hugetlbfs.h"
#include "libhugetlbfs_privutils.h"
#include "libhugetlbfs_internal.h"
#include "libhugetlbfs_debug.h"

static struct kernel_version running_kernel_version;

/* This mask should always be 32 bits, regardless of the platform word size */
static unsigned int feature_mask;

static struct feature kernel_features[] = {
	[HUGETLB_FEATURE_PRIVATE_RESV] = {
		.name			= "private_reservations",
		.required_version	= "2.6.27-rc1",
	},
	[HUGETLB_FEATURE_SAFE_NORESERVE] = {
		.name			= "noreserve_safe",
		.required_version	= "2.6.34",
	},
	[HUGETLB_FEATURE_MAP_HUGETLB] = {
		.name			= "map_hugetlb",
		.required_version	= "2.6.32",
	}
};

static void debug_kernel_version(void)
{
	struct kernel_version *ver = &running_kernel_version;

	INFO("Parsed kernel version: [%u] . [%u] . [%u] ",
		ver->major, ver->minor, ver->release);
	if (ver->post)
		INFO_CONT(" [post-release: %u]\n", ver->post);
	else if (ver->pre)
		INFO_CONT(" [pre-release: %u]\n", ver->pre);
	else
		INFO_CONT("\n");
}

static int str_to_ver(const char *str, struct kernel_version *ver)
{
	char *start;
	char *end;

	/* Clear out version struct */
	ver->major = ver->minor = ver->release = ver->post = ver->pre = 0;

	/*
	 * The kernel always starts x.y.z
	 *
	 * Note: strtol is used in place of sscanf because when heap override is
	 * used this step happens before the _morecore replacement and sscanf
	 * does an internal heap allocation.  This mean that the next allocation
	 * from the heap would be on small pages until the first block allocated
	 * by _morecore is exhausted
	 */
	errno = 0;
	ver->major = strtol(str, &end, 10);
	if (!ver->major && errno == EINVAL) {
		ERROR("Unable to determine base kernel version: %s\n",
			strerror(errno));
		return -1;
	}

	start = end + 1;
	errno = 0;
	ver->minor = strtol(start, &end, 10);
	if (!ver->minor && errno == EINVAL) {
		ERROR("Unable to determine base kernel version: %s\n",
			strerror(errno));
		return -1;
	}

	start = end + 1;
	errno = 0;
	ver->release = strtol(start, &end, 10);
	if (!ver->release && errno == EINVAL) {
		ERROR("Unable to determine base kernel version: %s\n",
			strerror(errno));
		return -1;
	}

	/* Try to match a post/stable version */
	start = end + 1;
	if (*end == '.') {
		ver->post = strtol(start, &end, 10);
		if (!ver->post && errno == EINVAL)
			return 0;
	}

	/* Try to match a preN/rcN version */
	start = end + 1;
	if (*end == '-') {
		if (*start == 'r' && *(start + 1) == 'c')
			start += 2;
		else if (*start == 'p' &&
			 *(start + 1) == 'r' &&
			 *(start + 2) == 'e')
			start += 3;
		else {
			/*
			 * For now we ignore any extraversions besides
			 * pre and rc versions and treat them as equal
			 * to the base version.
			 */
			return 0;
		}

		ver->pre = strtol(start, &end, 10);
	}

	return 0;
}

static int int_cmp(int a, int b)
{
	if (a < b)
		return -1;
	if (a > b)
		return 1;
	else
		return 0;
}

/*
 * Pre-release kernels have the following compare rules:
 * 	X.Y.(Z - 1) < X.Y.Z-rcN < X.Y.X
 * This order can be enforced by simply decrementing the release (for
 * comparison purposes) when there is a pre/rc modifier in effect.
 */
static int ver_cmp_release(struct kernel_version *ver)
{
	if (ver->pre)
		return ver->release - 1;
	else
		return ver->release;
}

static int ver_cmp(struct kernel_version *a, struct kernel_version *b)
{
	int ret, a_release, b_release;

	if ((ret = int_cmp(a->major, b->major)) != 0)
		return ret;

	if ((ret = int_cmp(a->minor, b->minor)) != 0)
		return ret;

	a_release = ver_cmp_release(a);
	b_release = ver_cmp_release(b);
	if ((ret = int_cmp(a_release, b_release)) != 0)
		return ret;

	if ((ret = int_cmp(a->post, b->post)) != 0)
		return ret;

	if ((ret = int_cmp(a->pre, b->pre)) != 0)
		return ret;

	/* We ignore forks (such as -mm and -mjb) */
	return 0;
}

int test_compare_kver(const char *a, const char *b)
{
	struct kernel_version ka, kb;

	if (str_to_ver(a, &ka) < 0)
		return -EINVAL;
	if (str_to_ver(b, &kb) < 0)
		return -EINVAL;
	return ver_cmp(&ka, &kb);
}

int hugetlbfs_test_feature(int feature_code)
{
	if (feature_code >= HUGETLB_FEATURE_NR) {
		ERROR("hugetlbfs_test_feature: invalid feature code\n");
		return -EINVAL;
	}
	return feature_mask & (1 << feature_code);
}

static void print_valid_features(void)
{
	int i;

	ERROR("HUGETLB_FEATURES=\"<feature>[,<feature>] ...\"\n");
	ERROR_CONT("Valid features:\n");
	for (i = 0; i < HUGETLB_FEATURE_NR; i++)
		ERROR_CONT("\t%s, no_%s\n", kernel_features[i].name,
						kernel_features[i].name);
}

static int check_features_env_valid(const char *env)
{
	const char *pos = env;
	int i;

	while (pos && *pos != '\0') {
		int match = 0;
		char *next;

		if (*pos == ',')
			pos++;
		next = strchrnul(pos, ',');
		if (strncmp(pos, "no_", 3) == 0)
			pos += 3;

		for (i = 0; i < HUGETLB_FEATURE_NR; i++) {
			char *name = kernel_features[i].name;
			if (strncmp(pos, name, next - pos) == 0) {
				match = 1;
				break;
			}
		}
		if (!match) {
			print_valid_features();
			return -1;
		}
		pos = next;
	}
	return 0;
}

void setup_features()
{
	struct utsname u;
	int i;

	if (uname(&u)) {
		ERROR("Getting kernel version failed: %s\n", strerror(errno));
		return;
	}

	str_to_ver(u.release, &running_kernel_version);
	debug_kernel_version();

	/* Check if the user has overrided any features */
	if (__hugetlb_opts.features &&
		check_features_env_valid(__hugetlb_opts.features) == -1) {
		ERROR("HUGETLB_FEATURES was invalid -- ignoring.\n");
		__hugetlb_opts.features = NULL;
	}

	for (i = 0; i < HUGETLB_FEATURE_NR; i++) {
		struct kernel_version ver;
		char *name = kernel_features[i].name;
		char *pos;

		str_to_ver(kernel_features[i].required_version, &ver);

		/* Has the user overridden feature detection? */
		if (__hugetlb_opts.features &&
			(pos = strstr(__hugetlb_opts.features, name))) {
			INFO("Overriding feature %s: ", name);
			/* If feature is preceeded by 'no_' then turn it off */
			if (((pos - 3) >= __hugetlb_opts.features) &&
				!strncmp(pos - 3, "no_", 3))
				INFO_CONT("no\n");
			else {
				INFO_CONT("yes\n");
				feature_mask |= (1UL << i);
			}
			continue;
		}

		/* Is the running kernel version newer? */
		if (ver_cmp(&running_kernel_version, &ver) >= 0) {
			INFO("Feature %s is present in this kernel\n",
				kernel_features[i].name);
			feature_mask |= (1UL << i);
		}
	}
}