mirror of
https://github.com/SCST-project/scst.git
synced 2026-08-26 00:56:38 +00:00
Gleb Chesnokov
3a6fb66c83
Procfs support was removed in 2019, but dead configuration guards, patch specialization logic and unused declarations remained. Remove these remnants and simplify paths that can no longer receive procfs-only objects.
786 lines
25 KiB
Awk
Executable File
786 lines
25 KiB
Awk
Executable File
#!/usr/bin/gawk -f
|
|
|
|
############################################################################
|
|
#
|
|
# Script that removes preprocessor checks on the kernel version. Somewhat
|
|
# related to the v4l-scripts-gentree.pl script.
|
|
#
|
|
# Copyright (C) 2008-2009 Bart Van Assche <bvanassche@acm.org>
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation, version 2
|
|
# of the License.
|
|
#
|
|
# This program 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 General Public License for more details.
|
|
#
|
|
############################################################################
|
|
|
|
# Usage:
|
|
# * Specify the kernel version code and optionally the RHEL version as follows:
|
|
# -v kernel_version=... -vRHEL_MAJOR=... -vRHEL_MINOR=...
|
|
# * Provide the patch to be processed to stdin.
|
|
#
|
|
# The output of this script will be a patch that is specialized for the
|
|
# specified kernel version.
|
|
|
|
|
|
# Convert a kernel version in the x.y.z format into numeric form, just like
|
|
# the KERNEL_VERSION() macro.
|
|
|
|
function version_number(a, b, c) {
|
|
return a * 65536 + b * 256 + (c > 255 ? 255 : c);
|
|
}
|
|
|
|
function version_code(kver, array) {
|
|
if (!match(kver, "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$", array))
|
|
match(kver, "^([0-9]+)\\.([0-9]+)$", array)
|
|
return version_number(array[1], array[2], array[3]);
|
|
}
|
|
|
|
|
|
# Evaluate a preprocessor statement via repeated substitutions.
|
|
# Mathematicians call this algorithm 'term rewriting'.
|
|
# Note: the order in which the substitutions appear below is important --
|
|
# it is the same order as the order of operators in C.
|
|
|
|
function evaluate(stmnt, pattern, arg, op, result) {
|
|
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (a) %s */\n", stmnt
|
|
|
|
# Remove C-style comments.
|
|
gsub("[[:blank:]]*\\/\\*[^*]*\\*\\/[[:blank:]]*", "", stmnt)
|
|
|
|
# Remove the spaces before the #-sign.
|
|
gsub("^+[[:blank:]]*#[[:blank:]]*", "+#", stmnt)
|
|
|
|
if (match(stmnt, "^+#ifdef (.*)$", arg))
|
|
{
|
|
stmnt = "+#if defined(" arg[1] ")"
|
|
}
|
|
|
|
if (match(stmnt, "^+#ifndef (.*)$", arg))
|
|
{
|
|
stmnt = "+#if !defined(" arg[1] ")"
|
|
}
|
|
|
|
# See also commit c9c9762d4d44 ("block: return the correct bvec when checking
|
|
# for gaps"; v5.14-rc1).
|
|
gsub("defined\\(bio_multiple_segments\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 13, 0))", stmnt)
|
|
|
|
gsub("defined\\(REGISTER_MAD_AGENT_HAS_FLAGS_ARG\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 6 * 256 + 9)", stmnt)
|
|
|
|
gsub("SOCK_RECVMSG_HAS_FOUR_ARGS",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0) \\&\\& " \
|
|
"!defined(UEK_KABI_RENAME))", stmnt)
|
|
|
|
gsub("defined\\(USE_PRE_440_WR_STRUCTURE\\)",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(4, 4, 0) \\&\\& " \
|
|
"RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(IB_CREATE_CQ_HAS_INIT_ATTR\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(CREATE_SEND_MAD_HAS_AH_ARG\\)",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16))", stmnt)
|
|
|
|
gsub("defined\\(CREATE_SEND_MAD_HAS_BASE_ARG\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(IB_CM_LISTEN_TAKES_FOURTH_ARG\\)",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0) \\&\\& " \
|
|
"RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(IB_CM_LISTEN_TAKES_THIRD_ARG\\)",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0) \\&\\& " \
|
|
"!(RHEL_MAJOR -0 == 8 \\&\\& RHEL_MINOR -0 >= 9 || " \
|
|
"RHEL_MAJOR -0 == 9 \\&\\& RHEL_MINOR -0 >= 3))", stmnt)
|
|
|
|
gsub("IB_CLIENT_ADD_ONE_RETURNS_INT",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 8 * 256 + 4)", stmnt)
|
|
|
|
gsub("defined\\(IB_CLIENT_REMOVE_TAKES_TWO_ARGS\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 3, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(IB_QUERY_GID_HAS_ATTR_ARG\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("RDMA_CREATE_ID_TAKES_NET_ARG",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(HAVE_DEV_ATTR_MAX_RECV_SGE\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 7)", stmnt)
|
|
|
|
gsub("HAVE_DEV_ATTR_MAX_SEND_SGE",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 7)", stmnt)
|
|
|
|
gsub("HAVE_RDMA_DESTROY_AH_WITH_FLAGS",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 21, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)
|
|
|
|
gsub("HAVE_RDMA_DESTROY_AH",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("HAVE_RDMA_QUERY_GID",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)
|
|
|
|
gsub("HAVE_SRP_DATA_DESC_IMM",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 21, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)
|
|
|
|
gsub("HAVE_STRUCT_SRP_LOGIN_REQ_RDMA",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 16, 0))", stmnt)
|
|
|
|
gsub("defined\\(HAVE_IB_EVENT_GID_CHANGE\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 6 * 256 + 9)", stmnt)
|
|
|
|
gsub("defined\\(HAVE_IB_QUERY_DEVICE\\)",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0) \\&\\& " \
|
|
"RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(MAD_HANDLER_TAKES_SEND_BUF\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(HAVE_IB_SET_CPI_RESP_TIME\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(IB_PD_HAS_LOCAL_DMA_LKEY\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)
|
|
|
|
gsub("defined\\(HAVE_IB_DMA_MAP_OPS\\)",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(0, 0, 0))", stmnt)
|
|
|
|
gsub("HAVE_IB_SG_DMA_LEN",
|
|
"(LINUX_VERSION_CODE < KERNEL_VERSION(5, 1, 0) \\&\\& " \
|
|
"RHEL_RELEASE_CODE -0 < 8 * 256 + 2)", stmnt)
|
|
|
|
gsub("RDMA_REJECT_HAS_FOUR_ARGS",
|
|
"(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) || " \
|
|
"RHEL_RELEASE_CODE -0 >= 8 * 256 + 4)", stmnt)
|
|
|
|
gsub("defined(ENABLE_NPIV)", 0, stmnt)
|
|
|
|
gsub("defined(FC_VPORT_CREATE_DEFINED)", 0, stmnt)
|
|
|
|
gsub("LINUX_VERSION_CODE", LINUX_VERSION_CODE, stmnt)
|
|
|
|
pattern="KERNEL_VERSION\\([[:blank:]]*([0-9]+)[[:blank:]]*,[[:blank:]]*([0-9]+)[[:blank:]]*,[[:blank:]]*([0-9]+)[[:blank:]]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, version_number(op[1], op[2], op[3]), stmnt)
|
|
}
|
|
|
|
gsub("defined\\(INSIDE_KERNEL_TREE\\)", "1", stmnt)
|
|
|
|
gsub("defined\\(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19\\)", "0", stmnt)
|
|
|
|
gsub("defined\\(CONFIG_SUSE_KERNEL\\)", "0", stmnt)
|
|
|
|
gsub("defined\\(CONFIG_SCST_STRICT_SERIALIZING\\)", "0", stmnt)
|
|
|
|
if (RHEL_MAJOR == "")
|
|
{
|
|
gsub("defined\\(RHEL_MAJOR\\)", "0", stmnt)
|
|
gsub("RHEL_MAJOR", "", stmnt)
|
|
}
|
|
else
|
|
{
|
|
gsub("defined\\(RHEL_MAJOR\\)", "1", stmnt)
|
|
gsub("RHEL_MAJOR", RHEL_MAJOR, stmnt)
|
|
}
|
|
|
|
if (RHEL_MINOR == "")
|
|
{
|
|
gsub("defined\\(RHEL_MINOR\\)", "0", stmnt)
|
|
gsub("RHEL_MINOR", "0", stmnt)
|
|
}
|
|
else
|
|
{
|
|
gsub("defined\\(RHEL_MINOR\\)", "1", stmnt)
|
|
gsub("RHEL_MINOR", RHEL_MINOR, stmnt)
|
|
}
|
|
|
|
gsub("defined\\(RHEL_RELEASE_VERSION\\)", "1", stmnt)
|
|
if (RHEL_MAJOR == "" || RHEL_MINOR == "")
|
|
{
|
|
gsub("defined\\(RHEL_RELEASE_CODE\\)", "0", stmnt)
|
|
gsub("RHEL_RELEASE_CODE", "", stmnt)
|
|
gsub("RHEL_RELEASE_VERSION\\([^,)]*,[ ]*[^,)]*\\)", "0", stmnt)
|
|
}
|
|
else
|
|
{
|
|
gsub("defined\\(RHEL_RELEASE_CODE\\)", "1", stmnt)
|
|
gsub("RHEL_RELEASE_CODE", RHEL_MAJOR * 256 + RHEL_MINOR, stmnt)
|
|
stmnt = gensub("RHEL_RELEASE_VERSION\\(([^,)]*),[ ]*([^,)]*)\\)",
|
|
"(\\1) * 256 + (\\2)", "g", stmnt)
|
|
}
|
|
|
|
if (MOFED_MAJOR == "") {
|
|
gsub("defined\\(MOFED_MAJOR\\)", "0", stmnt)
|
|
gsub("MOFED_MAJOR", "", stmnt)
|
|
} else {
|
|
gsub("defined\\(MOFED_MAJOR\\)", "1", stmnt)
|
|
gsub("MOFED_MAJOR", MOFED_MAJOR, stmnt)
|
|
}
|
|
|
|
if (MOFED_MINOR == "") {
|
|
gsub("defined\\(MOFED_MINOR\\)", "0", stmnt)
|
|
gsub("MOFED_MINOR", "", stmnt)
|
|
} else {
|
|
gsub("defined\\(MOFED_MINOR\\)", "1", stmnt)
|
|
gsub("MOFED_MINOR", MOFED_MINOR, stmnt)
|
|
}
|
|
|
|
gsub("defined\\(_COMPAT_LINUX_MM_H\\)", "0", stmnt)
|
|
gsub("defined\\(UEK_KABI_RENAME\\)", UEK_KABI_RENAME ? "1" : "0", stmnt)
|
|
|
|
if (SCST_IO_CONTEXT != "")
|
|
{
|
|
gsub("defined[[:blank:]]+SCST_IO_CONTEXT", SCST_IO_CONTEXT, stmnt)
|
|
gsub("defined[[:blank:]]*\\([[:blank:]]*SCST_IO_CONTEXT[[:blank:]]*\\)", SCST_IO_CONTEXT, stmnt)
|
|
}
|
|
|
|
if (generating_upstream_patch_defined)
|
|
{
|
|
gsub("defined[[:blank:]]+GENERATING_UPSTREAM_PATCH", 1, stmnt)
|
|
gsub("defined[[:blank:]]*\\([[:blank:]]*GENERATING_UPSTREAM_PATCH[[:blank:]]*\\)", 1, stmnt)
|
|
}
|
|
|
|
if (config_tcp_zero_copy_transfer_completion_notification_undefined)
|
|
{
|
|
gsub("defined[[:blank:]]+CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION", 0, stmnt)
|
|
gsub("defined[[:blank:]]*\\([[:blank:]]*CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION[[:blank:]]*\\)", 0, stmnt)
|
|
}
|
|
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (b) %s */\n", stmnt
|
|
|
|
do
|
|
{
|
|
last_stmnt = stmnt
|
|
|
|
pattern = "![[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, op[1] == 0, stmnt)
|
|
}
|
|
|
|
pattern = "![[:blank:]]*\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, op[1] == 0, stmnt)
|
|
}
|
|
|
|
pattern = "\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, op[1], stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*(\\*|/)[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
result="error"
|
|
if (op[2] == "*") result = op[1] * op[3]
|
|
else if (op[2] == "/" && op[3] != 0) result = op[1] / op[3]
|
|
sub(pattern, result, stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*(\\+|-)[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
result="error"
|
|
if (op[2] == "+") result = op[1] + op[3]
|
|
else if (op[2] == "-") result = op[1] - op[3]
|
|
sub(pattern, result, stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*(<<|>>)[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
result="error"
|
|
if (op[2] == "<<") result = int(op[1] * (2**op[3]))
|
|
else if (op[2] == ">>") result = int(op[1] / (2**op[3]))
|
|
sub(pattern, result, stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*(<|<=|>|>=|==|!=)[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
result="error"
|
|
if (op[2] == "<" ) result = op[1] < op[3]
|
|
else if (op[2] == "<=") result = op[1] <= op[3]
|
|
else if (op[2] == ">" ) result = op[1] > op[3]
|
|
else if (op[2] == ">=") result = op[1] >= op[3]
|
|
else if (op[2] == "==") result = op[1] == op[3]
|
|
else if (op[2] == "!=") result = op[1] != op[3]
|
|
sub(pattern, result, stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*&&[[:blank:]]*\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, (op[1] != 0) && (op[2] != 0), stmnt)
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*&&[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, (op[1] != 0) && (op[2] != 0), stmnt)
|
|
}
|
|
|
|
pattern="0[[:blank:]]*&&[[:blank:]]*defined\\([A-Za-z0-9_]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, 0, stmnt)
|
|
}
|
|
|
|
pattern="^+#(if|elif)[[:blank:]]*([01])[[:blank:]]*&&[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))$"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
stmnt = "+#" op[1] " " (op[2] != 0 ? op[3] : op[2])
|
|
}
|
|
|
|
pattern="^+#(if|elif)[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))&&[[:blank:]]*([01])[[:blank:]]*$"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
stmnt = "+#" op[1] " " (op[3] != 0 ? op[2] : op[3])
|
|
}
|
|
|
|
pattern="^+#(if|elif)[[:blank:]]*(!*[[:blank:]]*[A-Za-z0-9_]*)[[:blank:]]*&&[[:blank:]]*([01])[[:blank:]]*$"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
stmnt = "+#" op[1] " " (op[3] != 0 ? op[2] : op[3])
|
|
}
|
|
|
|
pattern="(-*[0-9]+)[[:blank:]]*\\|\\|[[:blank:]]*(-*[0-9]+)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, (op[1] != 0) || (op[2] != 0), stmnt)
|
|
}
|
|
|
|
pattern="^+#(if|elif)[[:blank:]]*([01])[[:blank:]]*\\|\\|[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))$"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
stmnt = "+#" op[1] " " (op[2] == 0 ? op[3] : op[2])
|
|
}
|
|
|
|
pattern="\\(([01])[[:blank:]]*\\|\\|[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, op[1] == 0 ? op[2] : op[1], stmnt)
|
|
}
|
|
|
|
pattern="\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
|
|
while (match(stmnt, pattern, op) != 0)
|
|
{
|
|
sub(pattern, op[1], stmnt)
|
|
}
|
|
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (c) %s -> %s */\n", last_stmnt, stmnt
|
|
|
|
} while (stmnt != last_stmnt)
|
|
|
|
return stmnt
|
|
}
|
|
|
|
|
|
# Evaluate !stmnt
|
|
function invert(stmnt) {
|
|
return evaluate(gensub("^+#if (.*)$", "+#if !(\\1)", "g", stmnt))
|
|
}
|
|
|
|
|
|
# Handle #if or #elif
|
|
|
|
function handle_if(evaluated)
|
|
{
|
|
# Only act on preprocessor conditional expressions with regard to the Linux
|
|
# kernel version, and do not interpret other expressions.
|
|
if ($0 ~ "LINUX_VERSION_CODE" \
|
|
|| $0 ~ "CONFIG_SCST_STRICT_SERIALIZING" \
|
|
|| $0 ~ "CREATE_SEND_MAD_HAS_AH_ARG" \
|
|
|| $0 ~ "CREATE_SEND_MAD_HAS_BASE_ARG" \
|
|
|| $0 ~ "ENABLE_NPIV" \
|
|
|| $0 ~ "FC_VPORT_CREATE_DEFINED" \
|
|
|| $0 ~ "HAVE_DEV_ATTR_MAX_RECV_SGE" \
|
|
|| $0 ~ "HAVE_DEV_ATTR_MAX_SEND_SGE" \
|
|
|| $0 ~ "HAVE_IB_DMA_MAP_OPS" \
|
|
|| $0 ~ "HAVE_IB_QUERY_DEVICE" \
|
|
|| $0 ~ "HAVE_IB_SET_CPI_RESP_TIME" \
|
|
|| $0 ~ "HAVE_IB_SG_DMA_LEN" \
|
|
|| $0 ~ "HAVE_RDMA_DESTROY_AH" \
|
|
|| $0 ~ "HAVE_RDMA_DESTROY_AH_WITH_FLAGS" \
|
|
|| $0 ~ "HAVE_RDMA_QUERY_GID" \
|
|
|| $0 ~ "HAVE_SRP_DATA_DESC_IMM" \
|
|
|| $0 ~ "HAVE_STRUCT_SRP_LOGIN_REQ_RDMA" \
|
|
|| $0 ~ "IB_CLIENT_ADD_ONE_RETURNS_INT" \
|
|
|| $0 ~ "IB_CLIENT_REMOVE_TAKES_TWO_ARGS" \
|
|
|| $0 ~ "IB_CM_LISTEN_TAKES_FOURTH_ARG" \
|
|
|| $0 ~ "IB_CM_LISTEN_TAKES_THIRD_ARG" \
|
|
|| $0 ~ "IB_CREATE_CQ_HAS_INIT_ATTR" \
|
|
|| $0 ~ "IB_PD_HAS_LOCAL_DMA_LKEY" \
|
|
|| $0 ~ "IB_QUERY_GID_HAS_ATTR_ARG" \
|
|
|| $0 ~ "INSIDE_KERNEL_TREE" \
|
|
|| $0 ~ "MAD_HANDLER_TAKES_SEND_BUF" \
|
|
|| $0 ~ "MOFED_MAJOR" \
|
|
|| $0 ~ "MOFED_MINOR" \
|
|
|| $0 ~ "RDMA_CREATE_ID_TAKES_NET_ARG" \
|
|
|| $0 ~ "RDMA_REJECT_HAS_FOUR_ARGS" \
|
|
|| $0 ~ "REGISTER_MAD_AGENT_HAS_FLAGS_ARG" \
|
|
|| $0 ~ "RHEL_MAJOR" \
|
|
|| $0 ~ "RHEL_MINOR" \
|
|
|| $0 ~ "RHEL_RELEASE_CODE" \
|
|
|| $0 ~ "SOCK_RECVMSG_HAS_FOUR_ARGS" \
|
|
|| $0 ~ "UEK_KABI_RENAME" \
|
|
|| $0 ~ "USE_PRE_440_WR_STRUCTURE" \
|
|
|| $0 ~ "_COMPAT_LINUX_MM_H" \
|
|
|| $0 ~ "bio_multiple_segments" \
|
|
|| generating_upstream_patch_defined \
|
|
&& $0 ~ "GENERATING_UPSTREAM_PATCH" \
|
|
|| $0 ~ "CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION" \
|
|
|| ($0 ~ "SCST_IO_CONTEXT" && SCST_IO_CONTEXT != ""))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
evaluated = "+#if undecided"
|
|
}
|
|
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (d) %s -> %s */\n", $0, evaluated
|
|
|
|
if (evaluated ~ "^+#if")
|
|
{
|
|
if_stmnt[if_nesting_level] = evaluated
|
|
any_section_output[if_nesting_level] = 0
|
|
decision[if_nesting_level] = evaluated
|
|
inv_decision[if_nesting_level] = evaluate(sprintf("+#if !%s", substr(evaluated, 6)))
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (f) %s / %s */\n", \
|
|
decision[if_nesting_level], inv_decision[if_nesting_level]
|
|
}
|
|
else
|
|
{
|
|
sub("^+#elif ",
|
|
sprintf("+#if %s \\&\\& ", substr(inv_decision[if_nesting_level], 6)),
|
|
evaluated)
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (e) %s */\n", evaluated
|
|
evaluated = evaluate(evaluated)
|
|
sub("^+#if", "+#elif", evaluated);
|
|
decision[if_nesting_level] = evaluated
|
|
inv_decision[if_nesting_level] \
|
|
= evaluate(sprintf("+#if %s && !%s", \
|
|
substr(inv_decision[if_nesting_level], 6), \
|
|
substr(evaluated, 8)))
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (f) %s / %s */\n", \
|
|
decision[if_nesting_level], inv_decision[if_nesting_level]
|
|
}
|
|
return evaluated
|
|
}
|
|
|
|
|
|
# Decide whether or not to print the preprocessor statement $0.
|
|
|
|
function process_preprocessor_statement(evaluated, condition) {
|
|
evaluated = evaluate($0)
|
|
condition = 1
|
|
ei = evaluated_if_stmnt[if_nesting_level];
|
|
if (evaluated ~ "^+#if")
|
|
{
|
|
if_nesting_level++
|
|
evaluated_if_stmnt[if_nesting_level] = evaluated
|
|
evaluated = handle_if(evaluated)
|
|
}
|
|
else if (evaluated ~ "^+#elif")
|
|
{
|
|
if (if_discarded[if_nesting_level]) {
|
|
sub("^+#elif", "+#if", input_line[0])
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (g0) -> %s */\n", evaluated
|
|
}
|
|
evaluated = handle_if(evaluated)
|
|
}
|
|
else if (evaluated ~ "^+#else")
|
|
{
|
|
decision[if_nesting_level] = inv_decision[if_nesting_level]
|
|
}
|
|
else if (evaluated ~ "^+#endif")
|
|
{
|
|
if_nesting_level--
|
|
}
|
|
else
|
|
{
|
|
condition = 0
|
|
}
|
|
if (condition)
|
|
{
|
|
output = 1
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (g1a) if_nesting_level = %d */\n", \
|
|
if_nesting_level
|
|
for (i = if_nesting_level; i >= 0; i--) {
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (g1b) %s: decision[%d] = %s */\n", \
|
|
evaluated, i, decision[i]
|
|
output = output && decision[i] !~ "^+#(if|elif) 0($| &&)"
|
|
}
|
|
if (output)
|
|
any_section_output[if_nesting_level] = 1
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (g2) %s: output = %d */\n", \
|
|
evaluated, output
|
|
}
|
|
if (output && (!condition || \
|
|
decision[if_nesting_level + (evaluated ~ "^+#endif$")] \
|
|
!~ "^+#(el|)if [01]"))
|
|
{
|
|
if (evaluated == "+#if undecided" \
|
|
|| (evaluated !~ "^+#if" \
|
|
&& evaluated !~ "^+#elif" \
|
|
&& evaluated !~ "^+#endif"))
|
|
{
|
|
for (i = 0; i < input_line_count; i++)
|
|
line[lines++] = input_line[i]
|
|
} else {
|
|
# If the statement being processed is an #else or #endif that is not a
|
|
# header file include guard and if that statement has a trailing comment,
|
|
# replace that comment by the partially evaluated matching #if expression.
|
|
if (evaluated ~ "^+#else" || evaluated ~ "^+#endif") {
|
|
if ($0 ~ "\\*/") {
|
|
if ($0 ~ "_H_* \\*/$") {
|
|
evaluated = $0
|
|
} else {
|
|
if (ei ~ "^+#if ")
|
|
ei = substr(ei, 6)
|
|
else if (ei ~ "^+#ifdef")
|
|
ei = substr(ei, 9)
|
|
match($0, "([^/ ]*)[[:blank:]]*/\\*[^*]*\\*/[[:blank:]]*", arg)
|
|
evaluated = sprintf("%s /* %s */", arg[1], ei);
|
|
if (match(evaluated, "([^/ ]*) */\\* defined\\(([^()]*)\\) \\*/",
|
|
arg))
|
|
{
|
|
evaluated = sprintf("%s /* %s */", arg[1], arg[2])
|
|
}
|
|
}
|
|
} else {
|
|
evaluated = $0
|
|
}
|
|
if (debug)
|
|
printf "/* debug specialize-patch: (h) %s */\n", evaluated
|
|
}
|
|
line[lines++] = evaluated
|
|
lines_less_added += input_line_count - 1
|
|
}
|
|
}
|
|
else
|
|
{
|
|
discard = 1
|
|
if (lines >= 1 && line[lines - 1] == "+")
|
|
delete_next_blank_line = 1
|
|
}
|
|
|
|
if (evaluated ~ "^+#if")
|
|
if_discarded[if_nesting_level] = discard
|
|
}
|
|
|
|
function reset_hunk_state_variables() {
|
|
lines = 0
|
|
lines_less_added = 0
|
|
lines_less_deleted = 0
|
|
output = 1
|
|
if_nesting_level = -1
|
|
delete_next_blank_line = 0
|
|
h[0] = ""
|
|
}
|
|
|
|
function dump_lines() {
|
|
# Detect empty hunks
|
|
first_modif = -1
|
|
for (i = 0; i < lines; i++)
|
|
{
|
|
if (line[i] ~ "^[+-]")
|
|
{
|
|
first_modif = i
|
|
break
|
|
}
|
|
}
|
|
|
|
# Dump line[] as a hunk, but only if the hunk is not empty.
|
|
if (first_modif >= 0)
|
|
{
|
|
if (h[0] != "")
|
|
printf "@@ -%d,%d +%d,%d @@%s\n",h[1],h[2]-lines_less_deleted,h[3],h[4]-lines_less_added,h[5]
|
|
for (i = 0; i < lines; i++) {
|
|
modifier = (LINUX_VERSION_CODE < version_code("4.19.0") &&
|
|
(RHEL_MAJOR == "" ||
|
|
RHEL_MAJOR * 256 + RHEL_MINOR < 7 * 256 + 7 ||
|
|
RHEL_MAJOR * 256 + RHEL_MINOR == 8 * 256 + 0) ?
|
|
"" : "const");
|
|
gsub("BAD_WR_MODIFIER", modifier, line[i])
|
|
gsub("CM_HANDLER_EVENT_MODIFIER", modifier, line[i])
|
|
print line[i]
|
|
}
|
|
}
|
|
}
|
|
|
|
BEGIN {
|
|
# Verify arguments.
|
|
if (kernel_version == "")
|
|
{
|
|
printf "Error: kernel_version was not specified.\n"
|
|
exit 1
|
|
}
|
|
LINUX_VERSION_CODE = version_code(kernel_version)
|
|
if (LINUX_VERSION_CODE < 2*65536)
|
|
{
|
|
printf "Error: kernel version (%s) is out of range.\n", kernel_version
|
|
exit 1
|
|
}
|
|
if (blank_deleted_code != 0 && blank_deleted_code != 1)
|
|
blank_deleted_code = 0
|
|
if (generating_upstream_patch_defined != 0 && generating_upstream_patch_defined != 1)
|
|
generating_upstream_patch_defined = 0
|
|
if (config_tcp_zero_copy_transfer_completion_notification_undefined != 0 && config_tcp_zero_copy_transfer_completion_notification_undefined != 1)
|
|
config_tcp_zero_copy_transfer_completion_notification_undefined = 0
|
|
# Variable initialization.
|
|
process_file = 0
|
|
reset_hunk_state_variables()
|
|
}
|
|
|
|
|
|
{
|
|
if (match($0, "^diff[ \t]+[^ \t]+[ \t]+[^ \t]+[ \t]+([^ \t]+)$", filename) \
|
|
|| match($0, "^\\+\\+\\+[ \t]+([^ \t]+)[ \t]+", filename))
|
|
{
|
|
# Start of new file.
|
|
dump_lines()
|
|
reset_hunk_state_variables()
|
|
process_file = match(filename[1], "\\.[ch]$") != 0 &&
|
|
match(filename[1], "drivers/scsi/qla2xxx/") == 0
|
|
}
|
|
|
|
if (!process_file)
|
|
{
|
|
sub("^+#ifdef INSIDE_KERNEL_TREE$", "+#if 1")
|
|
print
|
|
next
|
|
}
|
|
|
|
input_line[0] = $0
|
|
input_line_count = 1
|
|
# Join continued lines before processing these.
|
|
while (match($0, "\\\\$"))
|
|
{
|
|
previous_line = $0
|
|
sub("[ \t]*\\\\$", "", previous_line)
|
|
getline
|
|
input_line[input_line_count++] = $0
|
|
sub("^+[ \t]*", "", $0)
|
|
$0 = previous_line " " $0
|
|
}
|
|
|
|
discard = 0
|
|
# If the line currently being processed is a hunk header, print all lines
|
|
# that were stored in the array line[] since the last hunk header was read.
|
|
if (match($0, "^@@ -([0-9]*),([0-9]*) \\+([0-9]*),([0-9]*) @@(.*)$"))
|
|
{
|
|
/* print h[1], h[2], h[3], h[4], h[5] */
|
|
dump_lines()
|
|
reset_hunk_state_variables()
|
|
match($0, "^@@ -([0-9]*),([0-9]*) \\+([0-9]*),([0-9]*) @@(.*)$", h)
|
|
}
|
|
else if (delete_next_blank_line && $0 == "+")
|
|
{
|
|
discard = 1
|
|
delete_next_blank_line = 0
|
|
}
|
|
else if (lines >= 2 && !match(line[lines-2], ":$") &&
|
|
line[lines-1] == "+\x9return;" && $0 == "+}")
|
|
{
|
|
# Delete "return;" statements at the end of a function that are not
|
|
# preceded by a label.
|
|
line[lines-1] = $0
|
|
lines_less_added++
|
|
}
|
|
else
|
|
{
|
|
delete_next_blank_line = 0
|
|
if (match($0, "^+ *#"))
|
|
{
|
|
if (debug)
|
|
printf "/* debug specialize-patch: line %d: %s*/\n", NR, $0
|
|
process_preprocessor_statement()
|
|
}
|
|
else if (output)
|
|
{
|
|
# Store the lines that were just read.
|
|
for (i = 0; i < input_line_count; i++)
|
|
line[lines++] = input_line[i]
|
|
# Convert double blank lines into a single blank line.
|
|
if (line[lines-1] == "+")
|
|
delete_next_blank_line = 1
|
|
}
|
|
else
|
|
{
|
|
discard = 1
|
|
if (lines >= 1 && line[lines-1] == "+")
|
|
delete_next_blank_line = 1
|
|
}
|
|
}
|
|
if (discard)
|
|
{
|
|
for (i = 0; i < input_line_count; i++)
|
|
{
|
|
if (blank_deleted_code)
|
|
{
|
|
if (input_line[i] ~ "^+")
|
|
line[lines++] = "+"
|
|
else
|
|
line[lines++] = input_line[i]
|
|
}
|
|
else
|
|
{
|
|
if (input_line[i] ~ "^+")
|
|
lines_less_added++
|
|
else if (input_line[i] ~ "^-")
|
|
lines_less_deleted++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
END {
|
|
# Dump processed contents of the last read hunk.
|
|
dump_lines()
|
|
}
|
|
|
|
# Local variables:
|
|
# indent-tabs-mode: nil
|
|
# c-basic-offset: 2
|
|
# End:
|