| #! /bin/sh |
| # SPDX-License-Identifier: Apache-2.0 |
| # |
| # (c) 2019, Google |
| progname="${0##*/}" |
| |
| # Change to EXPORT_SYMBOL, EXPORT_SYMBOL_GPL or other namespace variant default |
| EXPORT_SYMBOL=${EXPORT_SYMBOL_GPL:-${progname#add_}} |
| |
| USAGE="USAGE: ${progname} [--no-skip-arch] < kernel_build_error_log |
| ${progname} [--no-skip-arch] kernel_build_error_log |
| grep /<module>[.]ko build_error_log | ${progname} [--no-skip-arch] |
| ${EDITOR:-vi} \`${progname} [--no-skip-arch] < kernel_build_error_log\` |
| |
| To acquire the kernel_build_error_log eg: |
| \$ ./build_sm8250.sh -j50 2>&1 | tee kernel_build_error_log |
| |
| To only create commit related to symbols needed for cam_spec.ko module: |
| \$ grep /cam_spec[.]ko kernel_build_error_log | ${progname} |
| |
| To only create commit related to a specific list of symbols, there is |
| the option to land just the symbols, no spaces, one per line, into a |
| manufactured or edited kernel_build_error_log and feed that to the script. |
| |
| The script will only affect the current directory level and downward, |
| this allows one to segregate the adjusted content. Any symbols that |
| are needed outside the range of that directory will result in errors |
| and the git commit phase will not be performed. |
| |
| Add ${EXPORT_SYMBOL} for any noted missing symbols, output the list of files |
| modified to stdout (so it can be passed to an editor command line should you |
| need to check or adjust the results). Automatically commit the list of files |
| into git. |
| |
| Deals as simply as it can to handle __trace_<symbols>, sorting the result. |
| |
| Keep in mind exports can change, be added or subtracted, and that preliminary |
| work may expose or remove required symbols to resolve during later work. As |
| such this script only adds, so you may need to revert the results and try |
| again to get the most up to date set. By making this part automated it can |
| deal with the tens or thousands of exports that need to be discovered or |
| added. If you need to adjust a subsystem, run this script in the subsystem |
| directory, and it will only adjust from that point downwards leaving other |
| higher up trees alone." |
| |
| if [ X"--help" = X"${1}" -o X"{-h}" = X"${1}" ]; then |
| echo "${USAGE}" >&2 |
| exit |
| fi |
| skip_arch=true |
| if [ X"--no-skip-arch" = X"${1}" ]; then |
| skip_arch=false |
| shift |
| fi |
| INPUT= |
| if [ 1 = ${#} ]; then |
| INPUT=${1} |
| shift |
| fi |
| if [ 0 != ${#} ]; then |
| echo "Unexpected Argument: ${*}" >&2 |
| echo >&2 |
| echo "${USAGE}" >&2 |
| exit 1 |
| fi |
| |
| # A _real_ embedded tab character |
| TAB="`echo | tr '\n' '\t'`" |
| # A _real_ embedded escape character |
| ESCAPE="`echo | tr '\n' '\033'`" |
| # A _real_ embedded carriage return character |
| CR="`echo | tr '\n' '\r'`" |
| # Colours |
| RED="${ESCAPE}[38;5;196m" |
| BLUE="${ESCAPE}[35m" |
| NORMAL="${ESCAPE}[0m" |
| |
| # Common grep/sed regex expressions |
| STRUCT_TYPE="struct[ ${TAB}][^ ${TAB}]\{1,\}" |
| VAR_TYPE="\(${STRUCT_TYPE}\|bool\|char\|int\|long\|long long\|u\{0,1\}int[0-9]*t\)[ ${TAB}]\{1,\}[*]\{0,1\}" |
| STRUCT_TYPE="${STRUCT_TYPE}[ ${TAB}]\{1,\}[*]\{0,1\}" |
| |
| # Files that exports should never exist, or need to be carefully considered |
| skip_arch_files() { |
| if ${skip_arch}; then |
| grep -v '\(^\|^[^:]*/\)arch/[^a][^r][^m][^:]*:' |
| else |
| cat - |
| fi |
| } |
| |
| # Following sucks in all the data from stdin or ${INPUT} |
| # Check for depmod output (undefined!) or built-in kernel complaints (undefined |
| # references). The later is not advised because it means the kernel may be |
| # dependent on a module, we collect it to provide a signal for future work. |
| echo "Reading symbols" >&2 |
| MODULES="` |
| cat ${INPUT:--} | |
| tr -d \"${CR}\" | |
| sed -n \ |
| -e '/^abi_gki_.*_whitelist$/d' \ |
| -e 's/^[_a-zA-Z][_a-zA-Z0-9]\{6,\}$/&/p' \ |
| -e 's/^ERROR: "\([^"]*\)" [[]\(.*[.]ko\)[]] undefined!$/\1 \2/p' \ |
| -e 's/^[^:]*:[0-9]*: undefined reference to \`\([^'\'']*\)'\''$/\1/p' | |
| sort -u`" |
| SYMBOLS="`echo \"${MODULES}\" | sed 's/ .*$//' | sort -u`" |
| if [ -z "${SYMBOLS}" ]; then |
| echo "${BLUE}WARNING${NORMAL}: no symbols found" >&2 |
| exit |
| fi |
| |
| SYMBOLS_PLUS_TRACE="${SYMBOLS}" |
| TRACE_MODULES="`echo \"${MODULES}\" | |
| sed -n 's/__tracepoint_.* //p' | |
| sort -u`" |
| TRACE_MODULES_2= |
| c=`echo "${TRACE_MODULES}" | wc -l` |
| if [ 1 -eq ${c} ];then |
| TRACE_MODULES="${TRACE_MODULES%/*.ko}" |
| if [ -z "${INPUT}" ]; then |
| TRACE_MODULES_2=* |
| else |
| TRACE_MODULES_2=${INPUT} |
| fi |
| elif [ -z "${INPUT}" ]; then |
| TRACE_MODULES=* |
| else |
| TRACE_MODULES=${INPUT} |
| fi |
| TRACE_FILE="`grep -rl '^#define CREATE_TRACE_POINTS' ${TRACE_MODULES}`" |
| if [ -z "${TRACE_FILE}" -a -n "${TRACE_MODULES_2}" ]; then |
| TRACE_FILE="`grep -rl '^#define CREATE_TRACE_POINTS' ${TRACE_MODULES_2}`" |
| fi |
| c=0 |
| if [ -n "${TRACE_FILE}" ]; then |
| c=`echo "${TRACE_FILE}" | wc -l` |
| fi |
| if [ 1 -eq ${c} ]; then |
| SYMBOLS_PLUS_TRACE="${SYMBOLS} |
| `echo \"${SYMBOLS}\" | |
| sed -n 's/^__tracepoint_\(.*\)/EXPORT_TRACEPOINT_SYMBOL_GPL(\1);/p'`" |
| else |
| TRACE_FILE= |
| fi |
| |
| echo "Finding symbols in the current tree" >&2 |
| DATA="`grep -Fr \"${SYMBOLS_PLUS_TRACE}\" * | |
| grep \"^[^:]*[.][cS]:[^ ${TAB}]\" | |
| skip_arch_files`" |
| echo "Editing the files that contain the symbols" >&2 |
| TMP=`mktemp -d` |
| |
| [ 'USAGE: report_strip_of_tag tag |
| |
| Report if a problematic function segment tag is stripped from the file |
| |
| expects ${F}, ${TMP}, ${TAB}, ${RED} and ${NORMAL} to be defined' ] |
| report_strip_of_tag() { |
| if diff --side-by-side --suppress-common-lines ${F} ${TMP}/${F##*/} | |
| sed -n "s/\(.*[ ${TAB}]\)\(__${1}\)\([^a-zA-Z0-9_].*[^ ${TAB}]\)[ ${TAB}]\{1,\}|[ ${TAB}]\{1,\}/\1${BLUE}\2${NORMAL}\3 -> /p" | |
| grep __${1} >&2; then |
| echo "${RED}ERROR${NORMAL}: scrubbing __${1} from function in ${F}" >&2 |
| echo " Compile check, possibly edit ${F} and friends." >&2 |
| echo " Then re-run ${progname} to complete." >&2 |
| echo FAILED |
| fi |
| } |
| |
| for s in ${SYMBOLS}; do |
| # Already there? |
| if echo "${DATA}" | |
| grep "EXPORT_\(TRACEPOINT_SYMBOL_GPL*(${s#__tracepoint_}\|SYMBOL\(_GPL\)*(${s}\))" >/dev/null; then |
| echo INFO: ${s} found and already exported >&2 |
| continue |
| fi |
| m="`echo \"${DATA}\" | grep \"^[^:]*:\([^ ${TAB}].*[ *]\|\)${s}(\"`" |
| c=0 |
| if [ -n "${m}" ]; then |
| c=`echo "${m}" | wc -l` |
| fi |
| if [ 0 -eq ${c} ]; then |
| m="`echo \"${DATA}\" | grep \"^[^:]*:\(const[ ${TAB}]\{1,\}\|\)${STRUCT_TYPE}${s}\([[][]]\|\) = {\"`" |
| c=0 |
| if [ -n "${m}" ]; then |
| c=`echo "${m}" | wc -l` |
| fi |
| if [ 0 -eq ${c} ]; then |
| m="`echo \"${DATA}\" | grep \"^[^:]*:\(const[ ${TAB}]\{1,\}\|\)${VAR_TYPE}${s}[\[ ${TAB};=]\"`" |
| c=0 |
| if [ -n "${m}" ]; then |
| c=`echo "${m}" | wc -l` |
| fi |
| if [ 0 -eq ${c} ]; then |
| if [ -z "${TRACE_FILE}" -o "${s}" = "${s#__tracepoint_}" ]; then |
| echo "${RED}ERROR${NORMAL}: ${s} not found" >&2 |
| if [ "${s}" != "${s#__tracepoint_}" -o "${s}" = "${s#__}" ]; then |
| echo FAILED |
| else |
| echo "${RED}WARNING${NORMAL}: ${s} might be a linker variable? skipping marking as failure" >&2 |
| fi |
| else |
| echo ${TRACE_FILE} ${s} |
| fi |
| elif [ 1 -eq ${c} ]; then |
| echo "${DATA}" | |
| sed -n "s/^\([^:]*\):\(const[ $TAB]\{1,\}\|\)${VAR_TYPE}${s}.*/\1 ${s}/p" |
| else |
| echo "${RED}ERROR${NORMAL}: ${c} matches: `echo \"${m}\" | |
| tr '\n' '&' | |
| sed -e 's/&$//' \ |
| -e 's/&/ & /g'`" >&2 |
| echo FAILED |
| fi |
| elif [ 1 -eq ${c} ]; then |
| echo "${DATA}" | |
| sed -n "s/^\([^:]*\):\(const[ $TAB]\{1,\}\|\)${STRUCT_TYPE}\(${s}\)\([[][]]\|\) = {.*/\1 \3/p" |
| else |
| echo "${RED}ERROR${NORMAL}: ${c} matches: `echo \"${m}\" | |
| tr '\n' '&' | |
| sed -e 's/&$//' \ |
| -e 's/&/ & /g'`" >&2 |
| echo FAILED |
| fi |
| elif [ 1 -eq ${c} ]; then |
| echo "${DATA}" | |
| sed -n "s/^\([^:]*\):\([^ ${TAB}].*[ *]\|\)\(${s}\)(.*/\1 \3/p" |
| else |
| echo "${RED}ERROR${NORMAL}: ${c} matches: `echo \"${m}\" | |
| tr '\n' '&' | |
| sed -e 's/&$//' \ |
| -e 's/&/ & /g'`" >&2 |
| echo FAILED |
| fi |
| done | |
| sort -u | |
| while read F s; do |
| if [ "FAILED" = "${F}" ]; then |
| echo FAILED |
| continue |
| fi |
| if [ "${s}" != "${s#__tracepoint_}" ]; then |
| sed "\$ { |
| /^[^E]/ { |
| a \ |
| |
| } |
| a \ |
| newEXPORT_TRACEPOINT_SYMBOL_GPL(${s#__tracepoint_}); |
| }" ${F} |
| else |
| cat ${F} |
| fi | |
| sed "/^\([^ ${TAB}].*[ *]\|\)${s}(/ { |
| : loop1 |
| N |
| /\(\n}\);*$/ { |
| s//\1/ |
| s/^\([^\n]*[^\n ${TAB}]\|\)[ ${TAB}]\{1,\}__\(init\|exit\)[ ${TAB}]\{1,\}\([^\n]*(\)/\1 \3/ |
| s/^\([^\n]*[^\n ${TAB}]\|\)[ ${TAB}]\{1,\}__\(init\|exit\)\([^ ${TAB}a-zA-Z0-9_][^\n]*(\)/\1 \3/ |
| s/^__\(init\|exit\)[ ${TAB}]\{1,\}\([^\n]*(\)/\2/ |
| s/^__\(init\|exit\)\([^ ${TAB}a-zA-Z0-9_][^\n]*(\)/\2/ |
| a \ |
| new${EXPORT_SYMBOL}(${s}); |
| b next1 |
| } |
| b loop1 |
| : next1 |
| } |
| /^\(const[ ${TAB}]\{1,\}\|\)${STRUCT_TYPE}${s}\([[][]]\|\)[ ${TAB}]*=[ ${TAB}]*{/ { |
| : loop2 |
| N |
| /\n};$/ { |
| a \ |
| new${EXPORT_SYMBOL}(${s}); |
| b next2 |
| } |
| b loop2 |
| : next2 |
| } |
| /^\(const[ ${TAB}]\{1,\}\|\)${VAR_TYPE}${s}\(\([[][]]\|\)[ ${TAB}]*=.*\|\);/ { |
| a \ |
| new${EXPORT_SYMBOL}(${s}); |
| } |
| /^\(const[ ${TAB}]\{1,\}\|\)${VAR_TYPE}${s}\([[][]]\|\)[ ${TAB}]*=[ ${TAB}]*{\{0,1\}\$/ { |
| : loop3 |
| N |
| /;$/ { |
| a \ |
| new${EXPORT_SYMBOL}(${s}); |
| b next3 |
| } |
| b loop3 |
| : next3 |
| }" | |
| sed '/^newEXPORT/ { |
| s//EXPORT/ |
| N |
| : loop |
| N |
| s/\(\n\)\n$/\1/ |
| t loop |
| }' >${TMP}/${F##*/} && |
| ! cmp -s ${F} ${TMP}/${F##*/} && |
| [ -s ${TMP}/${F##*/} ] && |
| report_strip_of_tag init && |
| report_strip_of_tag exit && |
| cp ${TMP}/${F##*/} ${F} && |
| echo INFO: export ${s} in ${F} >&2 || |
| ( |
| echo "${RED}ERROR${NORMAL}: export ${s} in ${F}" >&2 |
| echo FAILED |
| ) |
| echo ${F} |
| rm ${TMP}/${F##*/} |
| done >${TMP}/${progname}.out |
| FILES="`grep -v '^FAILED$' ${TMP}/${progname}.out | sort -u`" |
| echo "${FILES}" |
| grep '^FAILED$' ${TMP}/${progname}.out >/dev/null |
| ret=${?} |
| rm -rf ${TMP} |
| if [ 0 -ne ${ret} ]; then |
| echo "DONE" >&2 |
| GIT_FILES="`git diff | |
| sed -n 's@^diff --git a/\(.*\) b/\1$@\1@p' | |
| sort -u`" |
| if [ -z "${GIT_FILES}" ]; then |
| echo "${BLUE}WARNING${NORMAL}: no changes to commit" >&2 |
| if [ -n "${FILES}" ]; then |
| echo " but we altered files!" >&2 |
| fi |
| exit |
| fi |
| SEMI="" |
| if [ X"${GIT_FILES}" != X"`echo ${FILES} | tr ' ' '\n' | sort -u`" ]; then |
| SEMI="Semi-" |
| FILES=`echo ${FILES} ${GIT_FILES} | |
| tr ' ' '\n' | |
| sort -u` |
| echo "${BLUE}WARNING${NORMAL}: list of files in git different from files we expected to edit, continuation?" >&2 |
| fi |
| |
| AUTHOR_NAME="`git config user.name`" |
| AUTHOR_EMAIL="`git config user.email`" |
| if [ -z "${AUTHOR_EMAIL}" ]; then |
| AUTHOR_EMAIL="`${USER}@google.com`" |
| fi |
| if [ -z "${AUTHOR_NAME}" ]; then |
| convert_ldap_to_name() { |
| echo "${1##*/}" | |
| sed "s@[-_]@ @g |
| s@ *@ @g" | |
| sed 's@\(^\| \)a@\1A@g |
| s@\(^\| \)b@\1B@g |
| s@\(^\| \)c@\1C@g |
| s@\(^\| \)d@\1D@g |
| s@\(^\| \)e@\1E@g |
| s@\(^\| \)f@\1F@g |
| s@\(^\| \)g@\1G@g |
| s@\(^\| \)h@\1H@g |
| s@\(^\| \)i@\1I@g |
| s@\(^\| \)j@\1J@g |
| s@\(^\| \)k@\1K@g |
| s@\(^\| \)l@\1L@g |
| s@\(^\| \)m@\1M@g |
| s@\(^\| \)n@\1N@g |
| s@\(^\| \)o@\1O@g |
| s@\(^\| \)p@\1P@g |
| s@\(^\| \)q@\1Q@g |
| s@\(^\| \)r@\1R@g |
| s@\(^\| \)s@\1S@g |
| s@\(^\| \)t@\1T@g |
| s@\(^\| \)u@\1U@g |
| s@\(^\| \|Mc\)v@\1V@g |
| s@\(^\| \)w@\1W@g |
| s@\(^\| \)x@\1X@g |
| s@\(^\| \)y@\1Y@g |
| s@\(^\| \)z@\1Z@g' |
| } |
| AUTHOR_NAME="`convert_ldap_to_name ${USER}`" |
| fi |
| |
| git commit ${FILES} -m "GKI: add missing exports for <config>=m for <compatible> |
| |
| <edit> |
| |
| ${SEMI}Automatically generated by ${0##*/} |
| |
| The following symbols are exported: |
| `echo \"${SYMBOLS}\" | |
| sed 's/^/ - /'` |
| |
| Signed-off-by: ${AUTHOR_NAME} <${AUTHOR_EMAIL}> |
| Test: compile" || |
| echo "${RED}ERROR${NORMAL}: failed to commit changes to git" >&2 |
| exit |
| fi |
| echo "${RED}FAILED${NORMAL}: could not complete task" >&2 |
| exit 1 |
