X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttng-kernel-version.h;h=ed953fda250aaee49398965f0489b863d5db7987;hb=71d2f45d77134ed8c54a468969cf70e36bb81a3b;hp=46ee8ab9da4ff9b141272301f1295e6ee1d2c70a;hpb=05732a66bd235ff9ea4e73b5072872e1647775e1;p=lttng-modules.git diff --git a/lttng-kernel-version.h b/lttng-kernel-version.h index 46ee8ab9..ed953fda 100644 --- a/lttng-kernel-version.h +++ b/lttng-kernel-version.h @@ -1,50 +1,80 @@ -#ifndef _LTTNG_KERNEL_VERSION_H -#define _LTTNG_KERNEL_VERSION_H - -/* +/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1) + * * lttng-kernel-version.h * - * Contains helpers to check more complex kernel version conditions. + * Contains helpers to check kernel version conditions. * * Copyright (C) 2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_KERNEL_VERSION_H +#define _LTTNG_KERNEL_VERSION_H + +#include +#include + +/* + * The following defines are extracted from the toplevel Linux Makefile and + * passed on the command line -with '-D'. + */ + +#ifndef LTTNG_LINUX_MAJOR +#define LTTNG_LINUX_MAJOR 0 +#endif + +#ifndef LTTNG_LINUX_MINOR +#define LTTNG_LINUX_MINOR 0 +#endif + +#ifndef LTTNG_LINUX_PATCH +#define LTTNG_LINUX_PATCH 0 +#endif + +/* + * Some stable releases have overflowed the 8bits allocated to the sublevel in + * the version code. To determine if the current kernel is affected, use the + * sublevel version from the Makefile. This is currently true for the 4.4.256 + * and 4.9.256 stable releases. * - * 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; only - * version 2.1 of the License. - * - * 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. + * When the sublevel has overflowed, use the values from the Makefile instead + * of LINUX_VERSION_CODE from the kernel headers and allocate 16bits. + * Otherwise, keep using the version code from the headers to minimise the + * behavior change and avoid regressions. * - * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA + * Cast the result to uint64_t to prevent overflowing when we append distro + * specific version information. */ +#if (LTTNG_LINUX_PATCH >= 256) -#include +#define LTTNG_KERNEL_VERSION(a, b, c) \ + ((((a) << 24) + ((b) << 16) + (c)) * 1ULL) -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) -#include -#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) */ -#include -#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) */ +#define LTTNG_LINUX_VERSION_CODE \ + LTTNG_KERNEL_VERSION(LTTNG_LINUX_MAJOR, LTTNG_LINUX_MINOR, LTTNG_LINUX_PATCH) + +#else + +#define LTTNG_KERNEL_VERSION(a, b, c) (KERNEL_VERSION(a, b, c) * 1ULL) +#define LTTNG_LINUX_VERSION_CODE (LINUX_VERSION_CODE * 1ULL) + +#endif /* * This macro checks if the kernel version is between the two specified * versions (lower limit inclusive, upper limit exclusive). */ #define LTTNG_KERNEL_RANGE(a_low, b_low, c_low, a_high, b_high, c_high) \ - (LINUX_VERSION_CODE >= KERNEL_VERSION(a_low, b_low, c_low) && \ - LINUX_VERSION_CODE < KERNEL_VERSION(a_high, b_high, c_high)) + (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(a_low, b_low, c_low) && \ + LTTNG_LINUX_VERSION_CODE < LTTNG_KERNEL_VERSION(a_high, b_high, c_high)) + +/* Ubuntu */ #define LTTNG_UBUNTU_KERNEL_VERSION(a, b, c, d) \ - (((a) << 24) + ((b) << 16) + (c << 8) + (d)) + (((LTTNG_KERNEL_VERSION(a, b, c)) << 16) + (d)) #ifdef UTS_UBUNTU_RELEASE_ABI #define LTTNG_UBUNTU_VERSION_CODE \ - ((LINUX_VERSION_CODE << 8) + UTS_UBUNTU_RELEASE_ABI) + ((LTTNG_LINUX_VERSION_CODE << 16) + UTS_UBUNTU_RELEASE_ABI) #else #define LTTNG_UBUNTU_VERSION_CODE 0 #endif @@ -56,12 +86,14 @@ LTTNG_UBUNTU_VERSION_CODE < \ LTTNG_UBUNTU_KERNEL_VERSION(a_high, b_high, c_high, d_high)) +/* Debian */ + #define LTTNG_DEBIAN_KERNEL_VERSION(a, b, c, d, e, f) \ - (((((a) << 16) + ((b) << 8) + (c)) * 1000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) + (((LTTNG_KERNEL_VERSION(a, b, c)) * 1000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) #ifdef DEBIAN_API_VERSION #define LTTNG_DEBIAN_VERSION_CODE \ - ((LINUX_VERSION_CODE * 1000000ULL) + DEBIAN_API_VERSION) + ((LTTNG_LINUX_VERSION_CODE * 1000000ULL) + DEBIAN_API_VERSION) #else #define LTTNG_DEBIAN_VERSION_CODE 0 #endif @@ -73,4 +105,80 @@ LTTNG_DEBIAN_VERSION_CODE < \ LTTNG_DEBIAN_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) +#define LTTNG_RHEL_KERNEL_VERSION(a, b, c, d, e, f) \ + (((LTTNG_KERNEL_VERSION(a, b, c)) * 100000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) + +/* RHEL */ + +#ifdef RHEL_API_VERSION +#define LTTNG_RHEL_VERSION_CODE \ + ((LTTNG_LINUX_VERSION_CODE * 100000000ULL) + RHEL_API_VERSION) +#else +#define LTTNG_RHEL_VERSION_CODE 0 +#endif + +#define LTTNG_RHEL_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ + a_high, b_high, c_high, d_high, e_high, f_high) \ + (LTTNG_RHEL_VERSION_CODE >= \ + LTTNG_RHEL_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ + LTTNG_RHEL_VERSION_CODE < \ + LTTNG_RHEL_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) + +/* SUSE Linux enterprise */ + +#define LTTNG_SLE_KERNEL_VERSION(a, b, c, d, e, f) \ + (((LTTNG_KERNEL_VERSION(a, b, c)) * 100000000ULL) + ((d) * 100000) + ((e) * 100) + (f)) + +#ifdef SLE_API_VERSION +#define LTTNG_SLE_VERSION_CODE \ + ((LTTNG_LINUX_VERSION_CODE * 100000000ULL) + SLE_API_VERSION) +#else +#define LTTNG_SLE_VERSION_CODE 0 +#endif + +#define LTTNG_SLE_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ + a_high, b_high, c_high, d_high, e_high, f_high) \ + (LTTNG_SLE_VERSION_CODE >= \ + LTTNG_SLE_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ + LTTNG_SLE_VERSION_CODE < \ + LTTNG_SLE_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) + +/* Fedora */ + +#define LTTNG_FEDORA_KERNEL_VERSION(a, b, c, d) \ + (((LTTNG_KERNEL_VERSION(a, b, c)) * 10000ULL) + (d)) + +#ifdef FEDORA_REVISION_VERSION +#define LTTNG_FEDORA_VERSION_CODE \ + ((LTTNG_LINUX_VERSION_CODE * 10000ULL) + FEDORA_REVISION_VERSION) +#else +#define LTTNG_FEDORA_VERSION_CODE 0 +#endif + +#define LTTNG_FEDORA_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ + a_high, b_high, c_high, d_high) \ + (LTTNG_FEDORA_VERSION_CODE >= \ + LTTNG_FEDORA_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ + LTTNG_FEDORA_VERSION_CODE < \ + LTTNG_FEDORA_KERNEL_VERSION(a_high, b_high, c_high, d_high)) + +/* RT patch */ + +#define LTTNG_RT_KERNEL_VERSION(a, b, c, d) \ + (((LTTNG_KERNEL_VERSION(a, b, c)) << 16) + (d)) + +#ifdef RT_PATCH_VERSION +#define LTTNG_RT_VERSION_CODE \ + ((LTTNG_LINUX_VERSION_CODE << 16) + RT_PATCH_VERSION) +#else +#define LTTNG_RT_VERSION_CODE 0 +#endif + +#define LTTNG_RT_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ + a_high, b_high, c_high, d_high) \ + (LTTNG_RT_VERSION_CODE >= \ + LTTNG_RT_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ + LTTNG_RT_VERSION_CODE < \ + LTTNG_RT_KERNEL_VERSION(a_high, b_high, c_high, d_high)) + #endif /* _LTTNG_KERNEL_VERSION_H */