mirrors/scst
1
0
Fork 0
mirror of https://github.com/SCST-project/scst.git synced 2026-09-01 13:47:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
487b52c2f9f0c341d515f08491fcc24ba05211b2
scst/scripts/specialize-patch
T
Gleb Chesnokov 487b52c2f9 scripts/specialize-patch: Rebuild filtered hunks 
The regression became visible after commit 91517609cd
("scripts/generate-kernel-patch: Preserve split patches") preserved split
output that had previously been empty without diffstat.
specialize-patch kept the original hunk coordinates after dropping
version-dependent lines, so GNU patch rejected the generated qla.h patch.

Recalculate hunk coordinates and context after specialization removes added
lines. This prevents GNU patch from rejecting QLogic qla.h hunks for Linux
7.1 and 7.2.

Add a focused regression test for the normal and matching-line-number
specialization modes.
2026-08-26 16:25:41 +03:00

811 lines
26 KiB
Awk
Executable File
Raw Blame History

#!/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 >= 7 * 256)", 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\\)", "0", 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_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\\)", "1", 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\\(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
last_modif = -1
for (i = 0; i < lines; i++)
{
if (line[i] ~ "^[+-]")
{
if (first_modif < 0)
first_modif = i
last_modif = i
}
}
# Dump line[] as a hunk, but only if the hunk is not empty.
if (first_modif >= 0)
{
# Restore standard unified diff context after discarding added lines.
first_line = first_modif > context_lines ? first_modif - context_lines : 0
last_line = last_modif + context_lines < lines ? \
last_modif + context_lines : lines - 1
if (h[0] != "") {
old_start = h[1]
new_start = h[3] + new_line_adjustment
for (i = 0; i < first_line; i++) {
if (line[i] !~ "^\\+" && line[i] !~ "^\\\\")
old_start++
if (line[i] !~ "^-" && line[i] !~ "^\\\\")
new_start++
}
old_count = 0
new_count = 0
for (i = first_line; i <= last_line; i++) {
if (line[i] !~ "^\\+" && line[i] !~ "^\\\\")
old_count++
if (line[i] !~ "^-" && line[i] !~ "^\\\\")
new_count++
}
printf "@@ -%d,%d +%d,%d @@%s\n", old_start, old_count, \
new_start, new_count, h[5]
}
for (i = first_line; i <= last_line; 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]
}
}
if (h[0] != "")
new_line_adjustment += lines_less_deleted - lines_less_added
}
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 < version_number(3, 10, 0))
{
printf "Error: kernel version (%s) is not supported.\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.
context_lines = 3
process_file = 0
reset_hunk_state_variables()
}
{
if (match($0, "^diff[ \t]+[^ \t]+[ \t]+[^ \t]+[ \t]+([^ \t]+)$", filename) \
|| match($0, "^---[ \t]+([^ \t]+)[ \t]+", filename) \
|| match($0, "^\\+\\+\\+[ \t]+([^ \t]+)[ \t]+", filename))
{
# Start of new file.
dump_lines()
reset_hunk_state_variables()
new_line_adjustment = 0
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:
Reference in New Issue View Git Blame Copy Permalink